commit b97750eb1815973a377cb85ea2f6c62374a9995d Author: Karoy Lorentey Date: Thu Oct 1 16:37:33 2020 -0700 Initial commit. diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..24455f7 --- /dev/null +++ b/.gitignore @@ -0,0 +1,9 @@ +# Byte compiled Python modules. +*.pyc + +# Finder metadata +.DS_Store + +# Generated files from SPM and Xcode. +/.build +/.swiftpm diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..2b0a603 --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,55 @@ +# Code of Conduct +To be a truly great community, Swift.org needs to welcome developers from all walks of life, +with different backgrounds, and with a wide range of experience. A diverse and friendly +community will have more great ideas, more unique perspectives, and produce more great +code. We will work diligently to make the Swift community welcoming to everyone. + +To give clarity of what is expected of our members, Swift.org has adopted the code of conduct +defined by [contributor-covenant.org](https://www.contributor-covenant.org). This document is used across many open source +communities, and we think it articulates our values well. The full text is copied below: + +### Contributor Code of Conduct v1.3 +As contributors and maintainers of this project, and in the interest of fostering an open and +welcoming community, we pledge to respect all people who contribute through reporting +issues, posting feature requests, updating documentation, submitting pull requests or patches, +and other activities. + +We are committed to making participation in this project a harassment-free experience for +everyone, regardless of level of experience, gender, gender identity and expression, sexual +orientation, disability, personal appearance, body size, race, ethnicity, age, religion, or +nationality. + +Examples of unacceptable behavior by participants include: +- The use of sexualized language or imagery +- Personal attacks +- Trolling or insulting/derogatory comments +- Public or private harassment +- Publishing other’s private information, such as physical or electronic addresses, without explicit permission +- Other unethical or unprofessional conduct + +Project maintainers have the right and responsibility to remove, edit, or reject comments, +commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of +Conduct, or to ban temporarily or permanently any contributor for other behaviors that they +deem inappropriate, threatening, offensive, or harmful. + +By adopting this Code of Conduct, project maintainers commit themselves to fairly and +consistently applying these principles to every aspect of managing this project. Project +maintainers who do not follow or enforce the Code of Conduct may be permanently removed +from the project team. + +This code of conduct applies both within project spaces and in public spaces when an +individual is representing the project or its community. + +Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by +contacting a project maintainer at [conduct@swift.org](mailto:conduct@swift.org). All complaints will be reviewed and +investigated and will result in a response that is deemed necessary and appropriate to the +circumstances. Maintainers are obligated to maintain confidentiality with regard to the reporter +of an incident. + +*This policy is adapted from the Contributor Code of Conduct [version 1.3.0](http://contributor-covenant.org/version/1/3/0/).* + +### Reporting +A working group of community members is committed to promptly addressing any [reported +issues](mailto:conduct@swift.org). Working group members are volunteers appointed by the project lead, with a +preference for individuals with varied backgrounds and perspectives. Membership is expected +to change regularly, and may grow or shrink. diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..e36bf96 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,10 @@ +By submitting a pull request, you represent that you have the right to license +your contribution to Apple and the community, and agree by submitting the patch +that your contributions are licensed under the [Swift +license](https://swift.org/LICENSE.txt). + +--- + +Before submitting the pull request, please make sure you have tested your +changes and that they follow the Swift project [guidelines for contributing +code](https://swift.org/contributing/#contributing-code). diff --git a/LICENSE.txt b/LICENSE.txt new file mode 100644 index 0000000..61b0c78 --- /dev/null +++ b/LICENSE.txt @@ -0,0 +1,211 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + + + +## Runtime Library Exception to the Apache 2.0 License: ## + + + As an exception, if you use this Software to compile your source code and + portions of this Software are embedded into the binary product as a result, + you may redistribute such product without providing attribution as would + otherwise be required by Sections 4(a), 4(b) and 4(d) of the License. diff --git a/Package.swift b/Package.swift new file mode 100644 index 0000000..739fa6d --- /dev/null +++ b/Package.swift @@ -0,0 +1,35 @@ +// swift-tools-version:5.1 +//===----------------------------------------------------------------------===// +// +// 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 PackageDescription + +let package = Package( + name: "swift-atomics", + products: [ + .library( + name: "Atomics", + targets: ["Atomics"]), + ], + targets: [ + .target(name: "_AtomicsShims"), + .target( + name: "Atomics", + dependencies: ["_AtomicsShims"], + path: "Sources/Atomics" + ), + .testTarget( + name: "AtomicsTests", + dependencies: ["Atomics"] + ), + ] +) diff --git a/README.md b/README.md new file mode 100644 index 0000000..2aa6349 --- /dev/null +++ b/README.md @@ -0,0 +1,166 @@ +# Swift Atomics ⚛︎︎ + +[SE-0282]: https://github.com/apple/swift-evolution/blob/master/proposals/0282-atomics.md +[SE-0282r0]: https://github.com/apple/swift-evolution/blob/3a358a07e878a58bec256639d2beb48461fc3177/proposals/0282-atomics.md + +This package implements an atomics library for Swift, providing atomic operations for a variety of Swift types, including integers and pointer values. The goal is to enable intrepid developers to start building synchronization constructs directly in Swift. + +Atomic operations aren't subject to the usual exclusivity rules. The same memory location may be safely read and updated from multiple concurrent threads of execution, as long as all such access is done through atomic operations. For example, here is a trivial atomic counter: + +``` swift +import Atomics +import Dispatch + +let counter = ManagedAtomic(0) + +DispatchQueue.concurrentPerform(iterations: 10) { _ in + for _ in 0 ..< 1_000_000 { + counter.wrappingIncrement(ordering: .relaxed) + } +} +counter.load(ordering: .relaxed) // ⟹ 10_000_000 +``` + +The only way to access the counter value is to use one of the methods provided by `ManagedAtomic`, each of which implement a particular atomic operation, and each of which require an explicit ordering value. (Swift supports a subset of the C/C++ memory orderings.) + +## Getting Started + +To use `Atomics` in your own project, you need to set it up as a package dependency: + +```swift +// swift-tools-version:5.3 +import PackageDescription + +let package = Package( + name: "MyPackage", + dependencies: [ + .package( + url: "https://github.com/apple/swift-atomics.git", + from: "0.0.1" + ) + ], + targets: [ + .target( + name: "MyTarget", + dependencies: [ + .product(name: "Atomics", package: "swift-atomics") + ] + ) + ] +) +``` + +Because `Atomics` has not reached version 1.0 yet, source stability is only guaranteed within minor versions (e.g. between 0.0.1 and 0.0.2). If you don't want potentially source-breaking package updates, use this dependency specification instead: + +```swift + .package( + url: "https://github.com/apple/swift-atomics.git", + .upToNextMinor(from: "0.0.1") + ) +``` + + +## Supported Types + +The package implements atomic operations for the following Swift constructs, all of which conform to the public `AtomicValue` protocol: + +- Standard signed integer types (`Int`, `Int64`, `Int32`, `Int16`, `Int8`) +- Standard unsigned integer types (`UInt`, `UInt64`, `UInt32`, `UInt16`, `UInt8`) +- Booleans (`Bool`) +- Standard pointer types (`UnsafeRawPointer`, `UnsafeMutableRawPointer`, `UnsafePointer`, `UnsafeMutablePointer`), along with their optional-wrapped forms (such as `Optional>`) +- Unmanaged references (`Unmanaged`, `Optional>`) +- A special `DoubleWord` type that consists of two `UInt` values, `low` and `high`, providing double-wide atomic primitives +- Any `RawRepresentable` type whose `RawValue` is in turn an atomic type (such as simple custom enum types) +- Strong references to class instances that opted into atomic use (by conforming to the `AtomicReference` protocol) + +Of particular note is full support for atomic strong references. This provides a convenient memory reclamation solution for concurrent data structures that fits perfectly with Swift's reference counting memory management model. (Atomic strong references are implemented in terms of `DoubleWord` operations.) However, accessing an atomic strong reference is (relatively) expensive, so we also provide a separate set of efficient constructs (`ManagedAtomicLazyReference` and `UnsafeAtomicLazyReference`) for the common case of a lazily initialized (but otherwise constant) atomic strong reference. + +## Lock-Free vs Wait-Free Operations + +All atomic operations exposed by this package are guaranteed to have lock-free implementations. However, we do not guarantee wait-free operation -- depending on the capabilities of the target platform, some of the exposed operations may be implemented by compare-and-exchange loops. That said, all atomic operations map directly to dedicated CPU instructions where available -- to the extent supported by llvm & Clang. + +## Memory Management + +Atomic access is implemented in terms of dedicated atomic storage representations that are kept distinct from the corresponding regular (non-atomic) type. (E.g., the actual integer value underlying the counter above isn't directly accessible.) This has several advantages: + +- it helps prevent accidental non-atomic access to atomic variables, +- it enables custom storage representations (such as the one used by atomic strong references), and +- it is a better fit with the standard C atomics library that we use to implement the actual operations (as enabled by [SE-0282]). + +[SE-0282]: https://github.com/apple/swift-evolution/blob/master/proposals/0282-atomics.md + +While the underlying pointer-based atomic operations are exposed as static methods on the corresponding `AtomicStorage` types, we strongly recommend the use of higher-level atomic wrappers to manage the details of preparing/disposing atomic storage. This version of the library provides two wrapper types: + +- an easy to use, memory-safe `ManagedAtomic` generic class and +- a less convenient, but more flexible `UnsafeAtomic` generic struct. + +Both constructs provide the following operations on all `AtomicValue` types: + + +```swift +func load(ordering: AtomicLoadOrdering) -> Value +func store(_ desired: Value, ordering: AtomicStoreOrdering) +func exchange(_ desired: Value, ordering: AtomicUpdateOrdering) -> Value + +func compareExchange( + expected: Value, + desired: Value, + ordering: AtomicUpdateOrdering +) -> (exchanged: Bool, original: Value) + +func compareExchange( + expected: Value, + desired: Value, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering +) -> (exchanged: Bool, original: Value) + +func weakCompareExchange( + expected: Value, + desired: Value, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering +) -> (exchanged: Bool, original: Value) +``` + +Integer types come with additional atomic operations for incrementing or decrementing values and bitwise logical operations. `Bool` provides select additional boolean operations along the same vein. + +For an introduction to the APIs provided by this package, for now please see the [first version of SE-0282][SE-0282r0]. + +Note that when/if Swift gains support for non-copiable types, we expect to replace both `ManagedAtomic` and `UnsafeAtomic` with a single move-only atomic struct that combines the performance and versatility of `UnsafeAtomic` with the ease-of-use and memory safety of `ManagedAtomic`. + +The current version of the `Atomics` module does not implement APIs for tagged atomics (see issue #5), although it does expose a `DoubleWord` type that can be used to implement them. (Atomic strong references are already implemented in terms of `DoubleWord`, although in their current form they do not expose any user-customizable bits.) + +## Contributing + +Swift Atomics is a standalone library separate from the core Swift project. We expect some of the atomics APIs may eventually get incorporated into the Swift Standard Library. If and when that happens such changes will be proposed to the Swift Standard Library using the established evolution process of the Swift project. + +This library is licensed under the [Swift License]. For more information, see the Swift.org [Community Guidelines], [Contribution Guidelines], as well as the files [LICENSE.txt](./LICENSE.txt), [CONTRIBUTING.md](./CONTRIBUTING.md) and [CODE_OF_CONDUCT.md](./CODE_OF_CONDUCT.md) at the root of this repository. + +Swift Atomics uses GitHub issues to track bugs and enhancement requests. We use pull requests for development. + +[Swift License]: https://swift.org/LICENSE.txt +[Community Guidelines]: https://swift.org/community/ +[Contribution Guidelines]: https://swift.org/contributing/ + +## Development + +This package defines a large number of similar-but-not-quite-the-same operations. To make it easier to maintain these, we use code generation to produce these. + +A number of [source files](./Sources/Atomics) have a `.swift.gyb` extension. These are using a Python-based code generation utility called [gyb](./Utilities/gyb.py) which we also use within the Swift Standard Library (the name is short for Generate Your Boilerplate). To make sure the package remains buildable by SPM, the autogenerated output files are committed into this repository. You must never edit the contents of `autogenerated` subdirectories, or your changes will get overwritten the next time the code is regenerated. + +To regenerate sources (and to update the inventory of XCTest tests), you need to manually run the script [`generate-sources`](./generate-sources) in the root of this repository. This needs to be done every time you modify one of the template files. + +The same script also runs `swift test --generate-linuxmain` to register any newly added unit tests. + +In addition to gyb, the [`_AtomicsShims.h`](./Sources/_AtomicsShims/include/_AtomicsShims.h) header file uses the C preprocessor to define trivial wrapper functions for every supported atomic operation -- memory ordering pairing. + +⚛︎︎ + + + + + + + + diff --git a/Sources/Atomics/AtomicBool.swift.gyb b/Sources/Atomics/AtomicBool.swift.gyb new file mode 100644 index 0000000..69a0bc4 --- /dev/null +++ b/Sources/Atomics/AtomicBool.swift.gyb @@ -0,0 +1,269 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// + +%{ + from gyb_utils import ( + autogenerated_warning, loadOrderings, storeOrderings, updateOrderings, + boolOperations, lowerFirst, argLabel, shimOrders) +}% +${autogenerated_warning()} + +import _AtomicsShims + +extension Bool: AtomicValue { + 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 + ) -> 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, + 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, + 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, + 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, + 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, + 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, + 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 + static func atomicLoadThen${name}( + ${label} operand: Value, + at pointer: UnsafeMutablePointer, + 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 diff --git a/Sources/Atomics/AtomicInteger.swift b/Sources/Atomics/AtomicInteger.swift new file mode 100644 index 0000000..1c08796 --- /dev/null +++ b/Sources/Atomics/AtomicInteger.swift @@ -0,0 +1,120 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// + +/// A type that supports atomic integer operations through a separate +/// atomic storage representation. +/// +/// Atomic integer types provide a number of additional atomic +/// operations beyond the ones supported by `AtomicValue`, such as +/// atomic increments/decrements as well as atomic bitwise operations. +/// These may be mapped to dedicated instructions that can be more +/// efficient than implementations based on the general compare and +/// exchange operation; however, this depends on the capabilities of +/// the compiler and the underlying hardware. +public protocol AtomicInteger: AtomicValue, FixedWidthInteger +where AtomicRepresentation: AtomicIntegerStorage {} + +/// The storage representation for an atomic integer value, providing +/// pointer-based atomic operations. +/// +/// This is a low-level implementation detail of atomic types; instead +/// of directly handling conforming types, it is usually better to use +/// the `UnsafeAtomic` or `ManagedAtomic` generics -- these provide a +/// more reliable interface while ensuring that the storage is +/// correctly constructed and destroyed. +public protocol AtomicIntegerStorage: AtomicStorage { + /// 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 `prepareAtomicRepresentation(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: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value + + /// 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 `prepareAtomicRepresentation(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: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value + + /// 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 `prepareAtomicRepresentation(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: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value + + /// 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 `prepareAtomicRepresentation(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: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value + + /// 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 `prepareAtomicRepresentation(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: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value +} diff --git a/Sources/Atomics/AtomicLazyReference.swift.gyb b/Sources/Atomics/AtomicLazyReference.swift.gyb new file mode 100644 index 0000000..c8cebe7 --- /dev/null +++ b/Sources/Atomics/AtomicLazyReference.swift.gyb @@ -0,0 +1,199 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// +%{ + from gyb_utils import autogenerated_warning +}% +${autogenerated_warning()} + +/// An unsafe reference type holding a lazily initializable atomic +/// strong reference, requiring manual memory management of the +/// underlying storage representation. +/// +/// These values can be set (initialized) exactly once, but read many +/// times. +@frozen +public struct UnsafeAtomicLazyReference { + /// The value logically stored in an atomic lazy reference value. + public typealias Value = Instance? + + @usableFromInline + internal typealias _Rep = Optional>.AtomicRepresentation + + @usableFromInline + internal let _ptr: UnsafeMutablePointer<_Rep> + + /// Initialize an unsafe atomic lazy reference that uses the supplied memory + /// location for storage. The storage location must already be initialized to + /// represent a valid atomic value. + /// + /// At the end of the lifetime of the atomic value, you must manually ensure + /// that the storage location is correctly `dispose()`d, deinitalized and + /// deallocated. + /// + /// Note: This is not an atomic operation. + @_transparent // Debug performance + public init(@_nonEphemeral at pointer: UnsafeMutablePointer) { + // `Storage` is layout-compatible with its only stored property. + _ptr = UnsafeMutableRawPointer(pointer).assumingMemoryBound(to: _Rep.self) + } +} + +extension UnsafeAtomicLazyReference { + /// The storage representation for an atomic lazy reference value. + @frozen + public struct Storage { + @usableFromInline + internal var _storage: _Rep + + /// Initialize a new atomic lazy reference storage value holding `nil`. + /// + /// Note: This is not an atomic operation. This call may have side effects + /// (such as unpaired retains of strong references) that will need to be + /// undone by calling `dispose()` before the storage value is + /// deinitialized. + @inlinable @inline(__always) + public init() { + _storage = _Rep(nil) + } + + /// Prepare this atomic storage value for deinitialization, extracting the + /// logical value it represents. This invalidates this atomic storage; you + /// must not perform any operations on it after this call (except for + /// deinitialization). + /// + /// This call prevents resource leaks when destroying the storage + /// representation of certain `AtomicValue` types. (In particular, ones + /// that model strong references.) + /// + /// Note: This is not an atomic operation. Logically, it implements a + /// custom destructor for the underlying non-copiable value. + @inlinable @inline(__always) + @discardableResult + public mutating func dispose() -> Value { + defer { _storage = _Rep(nil) } + return _storage.dispose()?.takeRetainedValue() + } + } +} + +extension UnsafeAtomicLazyReference { + /// Create a new `UnsafeAtomicLazyReference` value by dynamically allocating + /// storage for it. + /// + /// This call is usually paired with `destroy` to get rid of the allocated + /// storage at the end of its lifetime. + /// + /// Note: This is not an atomic operation. + @inlinable + public static func create() -> Self { + let ptr = UnsafeMutablePointer.allocate(capacity: 1) + ptr.initialize(to: Storage()) + return Self(at: ptr) + } + + /// Disposes of the current value of the storage location corresponding to + /// this unsafe atomic lazy reference, then deinitializes and deallocates the + /// storage. + /// + /// Note: This is not an atomic operation. + /// + /// - Returns: The last value stored in the storage representation before it + /// was destroyed. + @discardableResult + @inlinable + public func destroy() -> Value { + // `Storage` is layout-compatible with its only stored property. + let address = UnsafeMutableRawPointer(_ptr) + .assumingMemoryBound(to: Storage.self) + defer { address.deallocate() } + return address.pointee.dispose() + } +} + +/// A reference type holding a lazily initializable atomic +/// strong reference, with automatic memory management. +/// +/// These values can be set (initialized) exactly once, but read many +/// times. +public class ManagedAtomicLazyReference { + /// The value logically stored in an atomic lazy reference value. + public typealias Value = Instance? + + @usableFromInline + internal typealias _Rep = Optional>.AtomicRepresentation + + @usableFromInline + internal let _storage: _Rep + + /// Initializes a new managed atomic lazy reference with a nil value. + @inlinable + public init() { + _storage = _Rep(nil) + } + + @_alwaysEmitIntoClient @inline(__always) + internal var _ptr: UnsafeMutablePointer<_Rep> { + _getUnsafePointerToStoredProperties(self).assumingMemoryBound(to: _Rep.self) + } +} + +% for type in ["UnsafeAtomicLazyReference", "ManagedAtomicLazyReference"]: +extension ${type} { + /// Atomically initializes this reference if its current value is nil, then + /// returns the initialized value. If this reference is already initialized, + /// then `storeIfNilThenLoad(_:)` discards its supplied argument and returns + /// the current value without updating it. + /// + /// The following example demonstrates how this can be used to implement a + /// thread-safe lazily initialized reference: + /// + /// ``` + /// class Image { + /// var _histogram: UnsafeAtomicLazyReference = ... + /// + /// // This is safe to call concurrently from multiple threads. + /// var atomicLazyHistogram: Histogram { + /// if let histogram = _histogram.load() { return foo } + /// // Note that code here may run concurrently on + /// // multiple threads, but only one of them will get to + /// // succeed setting the reference. + /// let histogram = ... + /// return _histogram.storeIfNilThenLoad(foo) + /// } + /// ``` + /// + /// This operation uses acquiring-and-releasing memory ordering. + public func storeIfNilThenLoad(_ desired: __owned Instance) -> Instance { + let desiredUnmanaged = Unmanaged.passRetained(desired) + let (exchanged, current) = _Rep.atomicCompareExchange( + expected: nil, + desired: desiredUnmanaged, + at: _ptr, + ordering: .acquiringAndReleasing) + if !exchanged { + // The reference has already been initialized. Balance the retain that + // we performed on `desired`. + desiredUnmanaged.release() + return current!.takeUnretainedValue() + } + return desiredUnmanaged.takeUnretainedValue() + } + + /// Atomically loads and returns the current value of this reference. + /// + /// The load operation is performed with the memory ordering + /// `AtomicLoadOrdering.acquiring`. + public func load() -> Instance? { + let value = _Rep.atomicLoad(at: _ptr, ordering: .acquiring) + return value?.takeUnretainedValue() + } +} diff --git a/Sources/Atomics/AtomicMemoryOrderings.swift b/Sources/Atomics/AtomicMemoryOrderings.swift new file mode 100644 index 0000000..71801bd --- /dev/null +++ b/Sources/Atomics/AtomicMemoryOrderings.swift @@ -0,0 +1,321 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 _AtomicsShims + +/// Specifies the memory ordering semantics of an atomic load operation. +@frozen +public struct AtomicLoadOrdering { + // This struct works like a non-frozen enum whose cases aren't reorderable. + + @usableFromInline + internal var _rawValue: Int + + @_semantics("constant_evaluable") + @inlinable @_transparent // Debug performance + internal init(_rawValue: Int) { + self._rawValue = _rawValue + } +} + +extension AtomicLoadOrdering { + // FIXME: Explain these ordering levels in more detail. + + /// Guarantees the atomicity of the specific operation on which it is applied, + /// but imposes no ordering constraints on any other variable accesses. + /// + /// This value corresponds to `std::memory_order_relaxed` in C++. + @_semantics("constant_evaluable") + @_alwaysEmitIntoClient + @_transparent // Debug performance + public static var relaxed: Self { + Self(_rawValue: 0) + } + + /// An acquiring load synchronizes with a releasing operation whose + /// value its reads. It ensures that the releasing and acquiring + /// threads agree that all subsequent variable accesses on the the + /// acquring thread happen after the atomic operation itself. + /// + /// This value corresponds to `std::memory_order_acquire` in C++. + @_semantics("constant_evaluable") + @_alwaysEmitIntoClient + @_transparent // Debug performance + public static var acquiring: Self { + Self(_rawValue: 2) + } + + /// A sequentially consistent load performs an acquiring load and + /// also guarantees that it and all other sequentially consistent + /// atomic operations (loads, stores, updates) appear to be executed + /// in a single, total sequential ordering. + /// + /// This value corresponds to `std::memory_order_seq_cst` in C++. + @_semantics("constant_evaluable") + @_alwaysEmitIntoClient + @_transparent // Debug performance + public static var sequentiallyConsistent: Self { + Self(_rawValue: 5) + } +} + +extension AtomicLoadOrdering: Equatable { + @_transparent // Debug performance + public static func ==(left: Self, right: Self) -> Bool { + return left._rawValue == right._rawValue + } +} + +extension AtomicLoadOrdering: Hashable { + @inlinable + public func hash(into hasher: inout Hasher) { + hasher.combine(_rawValue) + } +} + +extension AtomicLoadOrdering: CustomStringConvertible { + public var description: String { + switch self { + case .relaxed: return "relaxed" + case .acquiring: return "acquiring" + case .sequentiallyConsistent: return "sequentiallyConsistent" + default: return "AtomicLoadOrdering(\(_rawValue))" + } + } +} + +//------------------------------------------------------------------------------ + +/// Specifies the memory ordering semantics of an atomic store operation. +@frozen +public struct AtomicStoreOrdering { + // This struct works like a non-frozen enum whose cases aren't reorderable. + + @usableFromInline + internal var _rawValue: Int + + @_semantics("constant_evaluable") + @inlinable @_transparent // Debug performance + internal init(_rawValue: Int) { + self._rawValue = _rawValue + } +} + +extension AtomicStoreOrdering { + // FIXME: Explain these ordering levels in more detail. + + /// Guarantees the atomicity of the specific operation on which it is applied, + /// but imposes no ordering constraints on any other variable accesses. + /// + /// This value corresponds to `std::memory_order_relaxed` in C++. + @_semantics("constant_evaluable") + @_alwaysEmitIntoClient + @_transparent // Debug performance + public static var relaxed: Self { + Self(_rawValue: 0) + } + + /// A releasing store synchronizes with acquiring operations that + /// read the value it stores. It ensures that the releasing and + /// acquiring threads agree that all preceding variable accesses on + /// the releasing thread happen before the atomic operation itself. + /// + /// This value corresponds to `std::memory_order_release` in C++. + @_semantics("constant_evaluable") + @_alwaysEmitIntoClient + @_transparent // Debug performance + public static var releasing: Self { + Self(_rawValue: 3) + } + + /// A sequentially consistent store performs a releasing store and + /// also guarantees that it and all other sequentially consistent + /// atomic operations (loads, stores, updates) appear to be executed + /// in a single, total sequential ordering. + /// + /// This value corresponds to `std::memory_order_seq_cst` in C++. + @_semantics("constant_evaluable") + @_alwaysEmitIntoClient + @_transparent // Debug performance + public static var sequentiallyConsistent: Self { + Self(_rawValue: 5) + } +} + +extension AtomicStoreOrdering: Equatable { + @_transparent // Debug performance + public static func ==(left: Self, right: Self) -> Bool { + return left._rawValue == right._rawValue + } +} + +extension AtomicStoreOrdering: Hashable { + @inlinable + public func hash(into hasher: inout Hasher) { + hasher.combine(_rawValue) + } +} + +extension AtomicStoreOrdering: CustomStringConvertible { + public var description: String { + switch self { + case .relaxed: return "relaxed" + case .releasing: return "releasing" + case .sequentiallyConsistent: return "sequentiallyConsistent" + default: return "AtomicStoreOrdering(\(_rawValue))" + } + } +} + +//------------------------------------------------------------------------------ + +/// Specifies the memory ordering semantics of an atomic read-modify-write +/// operation. +@frozen +public struct AtomicUpdateOrdering { + // This struct works like a non-frozen enum whose cases aren't reorderable. + + @usableFromInline + internal var _rawValue: Int + + @_semantics("constant_evaluable") + @inlinable @_transparent // Debug performance + internal init(_rawValue: Int) { + self._rawValue = _rawValue + } +} + +extension AtomicUpdateOrdering { + // FIXME: Explain these ordering levels in more detail. + + /// Guarantees the atomicity of the specific operation on which it is applied, + /// but imposes no ordering constraints on any other variable accesses. + /// + /// This value corresponds to `std::memory_order_relaxed` in C++. + @_semantics("constant_evaluable") + @_alwaysEmitIntoClient + @_transparent // Debug performance + public static var relaxed: Self { + Self(_rawValue: 0) + } + + /// An acquiring update synchronizes with a releasing operation + /// whose value its reads. It ensures that the releasing and + /// acquiring threads agree that all subsequent variable accesses on + /// the acquring thread happen after the atomic operation itself. + /// + /// This value corresponds to `std::memory_order_acquire` in C++. + @_semantics("constant_evaluable") + @_alwaysEmitIntoClient + @_transparent // Debug performance + public static var acquiring: Self { + Self(_rawValue: 2) + } + + /// A releasing update synchronizes with acquiring operations that + /// read the value it stores. It ensures that the releasing and + /// acquiring threads agree that all preceding variable accesses on + /// the releasing thread happen before the atomic operation itself. + /// + /// This value corresponds to `std::memory_order_release` in C++. + @_semantics("constant_evaluable") + @_alwaysEmitIntoClient + @_transparent // Debug performance + public static var releasing: Self { + Self(_rawValue: 3) + } + + /// An acquiring-and-releasing operation is a combination of + /// `.acquiring` and `.releasing` operation on the same variable. + /// + /// This value corresponds to `std::memory_order_acq_rel` in C++. + @_semantics("constant_evaluable") + @_alwaysEmitIntoClient + @_transparent // Debug performance + public static var acquiringAndReleasing: Self { + Self(_rawValue: 4) + } + + /// A sequentially consistent update performs an + /// acquiring-and-releasing update and also guarantees that it and + /// all other sequentially consistent atomic operations (loads, stores, + /// updates) appear to be executed in a single, total sequential + /// ordering. + /// + /// This value corresponds to `std::memory_order_seq_cst` in C++. + @_semantics("constant_evaluable") + @_alwaysEmitIntoClient + @_transparent // Debug performance + public static var sequentiallyConsistent: Self { + Self(_rawValue: 5) + } +} + +extension AtomicUpdateOrdering: Equatable { + @_transparent // Debug performance + public static func ==(left: Self, right: Self) -> Bool { + return left._rawValue == right._rawValue + } +} + +extension AtomicUpdateOrdering: Hashable { + @inlinable + public func hash(into hasher: inout Hasher) { + hasher.combine(_rawValue) + } +} + +extension AtomicUpdateOrdering: CustomStringConvertible { + public var description: String { + switch self { + case .relaxed: return "relaxed" + case .acquiring: return "acquiring" + case .releasing: return "releasing" + case .acquiringAndReleasing: return "acquiringAndReleasing" + case .sequentiallyConsistent: return "sequentiallyConsistent" + default: return "AtomicUpdateOrdering(\(_rawValue))" + } + } +} + +/// Establishes a memory ordering without associating it with a +/// particular atomic operation. +/// +/// - A relaxed fence has no effect. +/// - An acquiring fence ties to any preceding atomic operation that +/// reads a value, and synchronizes with any releasing operation whose +/// value was read. +/// - A releasing fence ties to any subsequent atomic operation that +/// modifies a value, and synchronizes with any acquiring operation +/// that reads the result. +/// - An acquiring and releasing fence is a combination of an +/// acquiring and a releasing fence. +/// - A sequentially consistent fence behaves like an acquiring and +/// releasing fence, and ensures that the fence itself is part of +/// the single, total ordering for all sequentially consistent +/// operations. +/// +/// This operation corresponds to `std::atomic_thread_fence` in C++. +@_semantics("atomics.requires_constant_orderings") +@_transparent // Debug performance +public func atomicMemoryFence( + ordering: AtomicUpdateOrdering +) { + switch ordering { + case .relaxed: break + case .acquiring: _sa_thread_fence_acquire() + case .releasing: _sa_thread_fence_release() + case .acquiringAndReleasing: _sa_thread_fence_acq_rel() + case .sequentiallyConsistent: _sa_thread_fence_seq_cst() + default: fatalError() + } +} diff --git a/Sources/Atomics/AtomicOptional.swift b/Sources/Atomics/AtomicOptional.swift new file mode 100644 index 0000000..37b9d06 --- /dev/null +++ b/Sources/Atomics/AtomicOptional.swift @@ -0,0 +1,25 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// + +/// An atomic value that also supports atomic operations when wrapped +/// in an `Optional`. Atomic optional wrappable types come with a +/// standalone atomic representation for their optional-wrapped +/// variants. +public protocol AtomicOptionalWrappable: AtomicValue { + /// The atomic storage representation for `Optional`. + associatedtype AtomicOptionalRepresentation: AtomicStorage + where AtomicOptionalRepresentation.Value == Self? +} + +extension Optional: AtomicValue where Wrapped: AtomicOptionalWrappable { + public typealias AtomicRepresentation = Wrapped.AtomicOptionalRepresentation +} diff --git a/Sources/Atomics/AtomicRawRepresentable.swift b/Sources/Atomics/AtomicRawRepresentable.swift new file mode 100644 index 0000000..82ace1f --- /dev/null +++ b/Sources/Atomics/AtomicRawRepresentable.swift @@ -0,0 +1,126 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// + +extension RawRepresentable where Self: AtomicValue, RawValue: AtomicValue { + public typealias AtomicRepresentation = AtomicRawRepresentableStorage +} + +/// The default atomic storage representation for an atomic `RawRepresentable` +/// type whose `RawValue` conforms to `AtomicValue`. +@frozen +public struct AtomicRawRepresentableStorage: AtomicStorage +where Value: RawRepresentable, Value.RawValue: AtomicValue { + @usableFromInline internal typealias Storage = Value.RawValue.AtomicRepresentation + @usableFromInline + internal var _storage: Storage + + @_transparent @_alwaysEmitIntoClient + public init(_ value: __owned Value) { + _storage = Storage(value.rawValue) + } + + @_transparent @_alwaysEmitIntoClient + public func dispose() -> Value { + Value(rawValue: _storage.dispose())! + } + + @_transparent @_alwaysEmitIntoClient + internal static func _extract( + _ ptr: UnsafeMutablePointer + ) -> UnsafeMutablePointer { + // `Self` is layout-compatible with its only stored property. + UnsafeMutableRawPointer(ptr).assumingMemoryBound(to: Storage.self) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + let raw = Storage.atomicLoad(at: _extract(pointer), ordering: ordering) + return Value(rawValue: raw)! + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + Storage.atomicStore(desired.rawValue, at: _extract(pointer), ordering: ordering) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + let raw = Storage.atomicExchange(desired.rawValue, at: _extract(pointer), ordering: ordering) + return Value(rawValue: raw)! + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + let raw = Storage.atomicCompareExchange( + expected: expected.rawValue, + desired: desired.rawValue, + at: _extract(pointer), + ordering: ordering) + return (raw.exchanged, Value(rawValue: raw.original)!) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let raw = Storage.atomicCompareExchange( + expected: expected.rawValue, + desired: desired.rawValue, + at: _extract(pointer), + successOrdering: successOrdering, + failureOrdering: failureOrdering) + return (raw.exchanged, Value(rawValue: raw.original)!) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicWeakCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let raw = Storage.atomicWeakCompareExchange( + expected: expected.rawValue, + desired: desired.rawValue, + at: _extract(pointer), + successOrdering: successOrdering, + failureOrdering: failureOrdering) + return (raw.exchanged, Value(rawValue: raw.original)!) + } +} diff --git a/Sources/Atomics/AtomicStrongReference.swift b/Sources/Atomics/AtomicStrongReference.swift new file mode 100644 index 0000000..2128b98 --- /dev/null +++ b/Sources/Atomics/AtomicStrongReference.swift @@ -0,0 +1,571 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 _AtomicsShims + +/// A class type that supports atomic strong references. +public protocol AtomicReference: AnyObject, AtomicOptionalWrappable +where + AtomicRepresentation == AtomicReferenceStorage, + AtomicOptionalRepresentation == AtomicOptionalReferenceStorage +{ + // These were added as a workaround for https://bugs.swift.org/browse/SR-10251 + // FIXME: We should remove these once the package requires a + // compiler version that contains that fix. + override associatedtype AtomicRepresentation = AtomicReferenceStorage + override associatedtype AtomicOptionalRepresentation = + AtomicOptionalReferenceStorage +} + +/// The maximum number of other threads that can start accessing a +/// strong reference before an in-flight update needs to cancel and +/// retry. +@inlinable @inline(__always) +internal var _concurrencyWindow: Int { 20 } + +extension Unmanaged { + @inlinable + internal func retain(by delta: Int) { + _sa_retain_n(toOpaque(), UInt32(delta)) + } + + @inlinable + internal func release(by delta: Int) { + _sa_release_n(toOpaque(), UInt32(delta)) + } +} + +extension Unmanaged { + fileprivate static func passRetained(_ instance: __owned Instance?) -> Self? { + guard let instance = instance else { return nil } + return .passRetained(instance) + } +} + +extension DoubleWord { + fileprivate init(_raw: UnsafeRawPointer?, readers: Int, version: Int) { + let r = UInt(bitPattern: readers) & Self._readersMask + assert(r == readers) + self.init( + high: r | (UInt(bitPattern: version) &<< Self._readersBitWidth), + low: UInt(bitPattern: _raw)) + } + + @inline(__always) + fileprivate var _raw: UnsafeMutableRawPointer? { + get { UnsafeMutableRawPointer(bitPattern: low) } + set { low = UInt(bitPattern: newValue) } + } + + @inline(__always) + fileprivate var _unmanaged: Unmanaged? { + guard let raw = _raw else { return nil } + return .fromOpaque(raw) + } + + @inline(__always) + fileprivate static var _readersBitWidth: Int { + #if arch(i386) || arch(arm) || arch(arm64_32) + return 8 + #else + return 16 + #endif + } + + @inline(__always) + fileprivate static var _readersMask: UInt { (1 &<< _readersBitWidth) - 1 } + + @inline(__always) + fileprivate var _readers: Int { + get { Int(bitPattern: high & Self._readersMask) } + set { + let n = UInt(bitPattern: newValue) & Self._readersMask + assert(n == newValue) + high = (high & ~Self._readersMask) | n + } + } + + @inline(__always) + fileprivate var _version: Int { + get { Int(bitPattern: high &>> Self._readersBitWidth) } + set { + // Silently truncate any high bits we cannot store. + high = ( + (UInt(bitPattern: newValue) &<< Self._readersBitWidth) | + high & Self._readersMask) + } + } +} + +extension Optional where Wrapped == AnyObject { + fileprivate var _raw: UnsafeMutableRawPointer? { + guard let value = self else { return nil } + return Unmanaged.passUnretained(value).toOpaque() + } +} + +extension UnsafeMutablePointer where Pointee == _AtomicReferenceStorage { + @inlinable @inline(__always) + internal var _extract: UnsafeMutablePointer { + UnsafeMutableRawPointer(self) + .assumingMemoryBound(to: DoubleWord.AtomicRepresentation.self) + } +} + +@usableFromInline +internal struct _AtomicReferenceStorage { + internal typealias Storage = DoubleWord.AtomicRepresentation + internal var _storage: Storage + + @usableFromInline + internal init(_ value: __owned AnyObject?) { + let dword = DoubleWord( + _raw: Unmanaged.passRetained(value)?.toOpaque(), + readers: 0, + version: 0) + _storage = Storage(dword) + } + + @usableFromInline + internal func dispose() -> AnyObject? { + let value = _storage.dispose() + precondition(value._readers == 0, + "Attempt to dispose of a busy atomic strong reference \(value)") + return value._unmanaged?.takeRetainedValue() + } + + private static func _startLoading( + from pointer: UnsafeMutablePointer, + hint: DoubleWord? = nil + ) -> DoubleWord { + var old = hint ?? Storage.atomicLoad(at: pointer._extract, ordering: .relaxed) + if old._raw == nil { + atomicMemoryFence(ordering: .acquiring) + return old + } + // Increment reader count + while true { + let new = DoubleWord( + _raw: old._raw, + readers: old._readers &+ 1, + version: old._version) + var done: Bool + (done, old) = Storage.atomicWeakCompareExchange( + expected: old, + desired: new, + at: pointer._extract, + successOrdering: .acquiring, + failureOrdering: .acquiring) + if done { return new } + if old._raw == nil { return old } + } + } + + private static func _finishLoading( + _ value: DoubleWord, + from pointer: UnsafeMutablePointer + ) -> AnyObject? { + if value._raw == nil { return nil } + + // Retain result before we exit the access. + let result = value._unmanaged!.takeUnretainedValue() + + // Decrement reader count, using the version number to prevent any + // ABA issues. + var current = value + var done = false + repeat { + assert(current._readers >= 1) + (done, current) = Storage.atomicWeakCompareExchange( + expected: current, + desired: DoubleWord( + _raw: current._raw, + readers: current._readers &- 1, + version: current._version), + at: pointer._extract, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + } while !done && current._raw == value._raw && current._version == value._version + if !done { + // The reference changed while we were loading it. Cancel out + // our part of the refcount bias for the loaded instance. + value._unmanaged!.release() + } + return result + } + + @usableFromInline + internal static func atomicLoad( + at pointer: UnsafeMutablePointer + ) -> AnyObject? { + let new = _startLoading(from: pointer) + return _finishLoading(new, from: pointer) + } + + /// Try updating the current value from `old` to `new`. Don't do anything if the + /// current value differs from `old`. + /// + /// Returns a tuple `(exchanged, original)` where `exchanged` indicates whether the + /// update was successful. If `exchange` true, then `original` contains the original + /// reference value; otherwise `original` is nil. + /// + /// On an unsuccessful exchange, this function updates `old` to the latest known value, + /// and reenters the current thread as a reader of it. + private static func _tryExchange( + old: inout DoubleWord, + new: Unmanaged?, + at pointer: UnsafeMutablePointer + ) -> (exchanged: Bool, original: AnyObject?) { + let new = DoubleWord(_raw: new?.toOpaque(), readers: 0, version: old._version &+ 1) + guard let ref = old._unmanaged else { + // Try replacing the current nil value with the desired new value. + let (done, current) = Storage.atomicCompareExchange( + expected: old, + desired: new, + at: pointer._extract, + ordering: .acquiringAndReleasing) + if done { + return (true, nil) + } + // Someone else changed the reference. Give up for now. + old = _startLoading(from: pointer, hint: current) + return (false, nil) + } + assert(old._readers >= 1) + var delta = old._readers + _concurrencyWindow + ref.retain(by: delta) + while true { + // Try replacing the current value with the desired new value. + let (done, current) = Storage.atomicCompareExchange( + expected: old, + desired: new, + at: pointer._extract, + ordering: .acquiringAndReleasing) + if done { + // Successfully replaced the object. Clean up extra retains. + assert(current._readers == old._readers) + assert(current._raw == old._raw) + assert(current._readers <= delta) + ref.release(by: delta - current._readers + 1) // +1 is for our own role as a reader. + return (true, ref.takeRetainedValue()) + } + if current._version != old._version { + // Someone else changed the reference. Give up for now. + ref.release(by: delta + 1) // +1 covers our reader bias + old = _startLoading(from: pointer, hint: current) + return (false, nil) + } + // Some readers entered or left while we were processing things. Try again. + assert(current._raw == old._raw) + assert(current._raw != nil) + assert(current._readers >= 1) + if current._readers > delta { + // We need to do more retains to cover readers. + let d = current._readers + _concurrencyWindow + ref.retain(by: d - delta) + delta = d + } + old = current + } + } + + @usableFromInline + internal static func atomicExchange( + _ desired: __owned AnyObject?, + at pointer: UnsafeMutablePointer + ) -> AnyObject? { + let new = Unmanaged.passRetained(desired) + var old = _startLoading(from: pointer) + var (exchanged, original) = _tryExchange(old: &old, new: new, at: pointer) + while !exchanged { + (exchanged, original) = _tryExchange(old: &old, new: new, at: pointer) + } + return original + } + + @usableFromInline + internal static func atomicCompareExchange( + expected: AnyObject?, + desired: __owned AnyObject?, + at pointer: UnsafeMutablePointer + ) -> (exchanged: Bool, original: AnyObject?) { + let expectedRaw = expected._raw + let new = Unmanaged.passRetained(desired) + var old = _startLoading(from: pointer) + while old._raw == expectedRaw { + let (exchanged, original) = _tryExchange(old: &old, new: new, at: pointer) + if exchanged { + assert(original === expected) + return (true, original) + } + } + // We did not find the expected value. Cancel the retain of the new value + // and return the old value. + new?.release() + return (false, _finishLoading(old, from: pointer)) + } +} + +public struct AtomicReferenceStorage { + @usableFromInline + internal var _storage: _AtomicReferenceStorage + + @inlinable + public init(_ value: __owned Value) { + _storage = .init(value) + } + + @inlinable + public func dispose() -> Value { + return unsafeDowncast(_storage.dispose()!, to: Value.self) + } +} + +extension AtomicReferenceStorage { + @inlinable @inline(__always) + @_alwaysEmitIntoClient + static func _extract( + _ ptr: UnsafeMutablePointer + ) -> UnsafeMutablePointer<_AtomicReferenceStorage> { + // `Self` is layout-compatible with its only stored property. + return UnsafeMutableRawPointer(ptr) + .assumingMemoryBound(to: _AtomicReferenceStorage.self) + } +} + +extension AtomicReferenceStorage: AtomicStorage { + @inlinable @inline(__always) + @_alwaysEmitIntoClient + @_semantics("atomics.requires_constant_orderings") + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + // FIXME: All orderings are treated as acquiring-and-releasing. + let result = _AtomicReferenceStorage.atomicLoad(at: Self._extract(pointer)) + return unsafeDowncast(result!, to: Value.self) + } + + @inlinable @inline(__always) + @_alwaysEmitIntoClient + @_semantics("atomics.requires_constant_orderings") + public static func atomicStore( + _ desired: __owned Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + // FIXME: All orderings are treated as acquiring-and-releasing. + _ = _AtomicReferenceStorage.atomicExchange( + desired, + at: _extract(pointer)) + } + + @inlinable @inline(__always) + @_alwaysEmitIntoClient + @_semantics("atomics.requires_constant_orderings") + public static func atomicExchange( + _ desired: __owned Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + // FIXME: All orderings are treated as acquiring-and-releasing. + let result = _AtomicReferenceStorage.atomicExchange( + desired, + at: _extract(pointer)) + return unsafeDowncast(result!, to: Value.self) + } + + @inlinable @inline(__always) + @_alwaysEmitIntoClient + @_semantics("atomics.requires_constant_orderings") + public static func atomicCompareExchange( + expected: Value, + desired: __owned Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + // FIXME: All orderings are treated as acquiring-and-releasing. + let result = _AtomicReferenceStorage.atomicCompareExchange( + expected: expected, + desired: desired, + at: _extract(pointer)) + return (result.exchanged, unsafeDowncast(result.original!, to: Value.self)) + } + + @inlinable @inline(__always) + @_alwaysEmitIntoClient + @_semantics("atomics.requires_constant_orderings") + public static func atomicCompareExchange( + expected: Value, + desired: __owned Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + // FIXME: All orderings are treated as acquiring-and-releasing. + let result = _AtomicReferenceStorage.atomicCompareExchange( + expected: expected, + desired: desired, + at: _extract(pointer)) + return (result.exchanged, unsafeDowncast(result.original!, to: Value.self)) + } + + @inlinable @inline(__always) + @_alwaysEmitIntoClient + @_semantics("atomics.requires_constant_orderings") + public static func atomicWeakCompareExchange( + expected: Value, + desired: __owned Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + // FIXME: All orderings are treated as acquiring-and-releasing. + let result = _AtomicReferenceStorage.atomicCompareExchange( + expected: expected, + desired: desired, + at: _extract(pointer)) + return (result.exchanged, unsafeDowncast(result.original!, to: Value.self)) + } +} + +public struct AtomicOptionalReferenceStorage { + @usableFromInline + internal var _storage: _AtomicReferenceStorage + + @inlinable + public init(_ value: __owned Instance?) { + _storage = .init(value) + } + + @inlinable + public func dispose() -> Instance? { + guard let value = _storage.dispose() else { return nil } + return unsafeDowncast(value, to: Instance.self) + } +} + +extension AtomicOptionalReferenceStorage { + @inlinable @inline(__always) + @_alwaysEmitIntoClient + static func _extract( + _ ptr: UnsafeMutablePointer + ) -> UnsafeMutablePointer<_AtomicReferenceStorage> { + // `Self` is layout-compatible with its only stored property. + return UnsafeMutableRawPointer(ptr) + .assumingMemoryBound(to: _AtomicReferenceStorage.self) + } +} + +extension AtomicOptionalReferenceStorage: AtomicStorage { + public typealias Value = Instance? + + @inlinable @inline(__always) + @_alwaysEmitIntoClient + @_semantics("atomics.requires_constant_orderings") + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Instance? { + // FIXME: All orderings are treated as acquiring-and-releasing. + let result = _AtomicReferenceStorage.atomicLoad(at: Self._extract(pointer)) + guard let r = result else { return nil } + return unsafeDowncast(r, to: Instance.self) + } + + @inlinable @inline(__always) + @_alwaysEmitIntoClient + @_semantics("atomics.requires_constant_orderings") + public static func atomicStore( + _ desired: __owned Instance?, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + // FIXME: All orderings are treated as acquiring-and-releasing. + _ = _AtomicReferenceStorage.atomicExchange( + desired, + at: _extract(pointer)) + } + + @inlinable @inline(__always) + @_alwaysEmitIntoClient + @_semantics("atomics.requires_constant_orderings") + public static func atomicExchange( + _ desired: __owned Instance?, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Instance? { + // FIXME: All orderings are treated as acquiring-and-releasing. + let result = _AtomicReferenceStorage.atomicExchange( + desired, + at: _extract(pointer)) + guard let r = result else { return nil } + return unsafeDowncast(r, to: Instance.self) + } + + @inlinable @inline(__always) + @_alwaysEmitIntoClient + @_semantics("atomics.requires_constant_orderings") + public static func atomicCompareExchange( + expected: Instance?, + desired: __owned Instance?, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Instance?) { + // FIXME: All orderings are treated as acquiring-and-releasing. + let result = _AtomicReferenceStorage.atomicCompareExchange( + expected: expected, + desired: desired, + at: _extract(pointer)) + guard let original = result.original else { return (result.exchanged, nil) } + return (result.exchanged, unsafeDowncast(original, to: Instance.self)) + } + + @inlinable @inline(__always) + @_alwaysEmitIntoClient + @_semantics("atomics.requires_constant_orderings") + public static func atomicCompareExchange( + expected: Instance?, + desired: __owned Instance?, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Instance?) { + // FIXME: All orderings are treated as acquiring-and-releasing. + let result = _AtomicReferenceStorage.atomicCompareExchange( + expected: expected, + desired: desired, + at: _extract(pointer)) + guard let original = result.original else { return (result.exchanged, nil) } + return (result.exchanged, unsafeDowncast(original, to: Instance.self)) + } + + @inlinable @inline(__always) + @_alwaysEmitIntoClient + @_semantics("atomics.requires_constant_orderings") + public static func atomicWeakCompareExchange( + expected: Instance?, + desired: __owned Instance?, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Instance?) { + // FIXME: All orderings are treated as acquiring-and-releasing. + let result = _AtomicReferenceStorage.atomicCompareExchange( + expected: expected, + desired: desired, + at: _extract(pointer)) + guard let original = result.original else { return (result.exchanged, nil) } + return (result.exchanged, unsafeDowncast(original, to: Instance.self)) + } +} + diff --git a/Sources/Atomics/AtomicValue.swift b/Sources/Atomics/AtomicValue.swift new file mode 100644 index 0000000..6b07f14 --- /dev/null +++ b/Sources/Atomics/AtomicValue.swift @@ -0,0 +1,218 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// + +/// A type that supports atomic operations through a separate atomic storage +/// representation. +public protocol AtomicValue { + associatedtype AtomicRepresentation: AtomicStorage + where AtomicRepresentation.Value == Self +} + +/// The storage representation for an atomic value, providing pointer-based +/// atomic operations. This is a low-level implementation detail of atomic +/// types; instead of directly handling conforming types, it is usually better +/// to use the `UnsafeAtomic` or `ManagedAtomic` generics -- these provide more +/// convenient and safer interfaces while also ensuring that the storage is +/// correctly constructed and destroyed. +/// +/// Logically, atomic storage representations are neither value- nor reference +/// types: they should be treated as non-copiable values with a custom +/// destructor. Such constructs cannot currently be modeled directly in Swift, +/// so types conforming to this protocol must be handled carefully to prevent +/// accidental copying. For example, it usually isn't safe to pass around atomic +/// storage representations as function arguments or return values. Instead, +/// they are usually addressed through unsafe pointers. +public protocol AtomicStorage { + /// The type whose values this storage representation is representing. + associatedtype Value + + /// Encode the supplied value into its atomic storage representation. + /// + /// Note: This is not an atomic operation. This call may have side effects + /// (such as unpaired retains of strong references) that will need to be + /// undone by calling `dispose()` before the storage value is deinitialized. + init(_ value: __owned Value) + + /// Prepare this atomic storage value for deinitialization, extracting the + /// logical value it represents. This invalidates this atomic storage; you + /// must not perform any operations on it after this call (except for + /// deinitialization). + /// + /// This call prevents resource leaks when destroying the storage + /// representation of certain `AtomicValue` types. (In particular, ones that + /// model strong references.) + /// + /// Note: This is not an atomic operation. Logically, it implements a custom + /// destructor for the underlying non-copiable value. + __consuming func dispose() -> Value + + /// Atomically loads and returns the value referenced by the given pointer, + /// applying the specified memory ordering. + /// + /// - 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 current value referenced by `pointer`. + @_semantics("atomics.requires_constant_orderings") + static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value + + /// Atomically sets the value referenced by `pointer` to `desired`, + /// applying the specified memory ordering. + /// + /// - Parameter desired: The desired new 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. + @_semantics("atomics.requires_constant_orderings") + static func atomicStore( + _ desired: __owned Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) + + /// Atomically sets the value referenced by `pointer` to `desired` and returns + /// the original value, applying the specified memory ordering. + /// + /// - Parameter desired: The desired new 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. + @_semantics("atomics.requires_constant_orderings") + static func atomicExchange( + _ desired: __owned Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value + + /// Perform an atomic compare and exchange operation on the value referenced + /// by `pointer`, applying the specified memory ordering. + /// + /// This operation performs the following algorithm as a single atomic + /// transaction: + /// + /// ``` + /// atomic(self) { currentValue in + /// let original = currentValue + /// guard original == expected else { return (false, original) } + /// currentValue = desired + /// return (true, original) + /// } + /// ``` + /// + /// This method implements a "strong" compare and exchange operation + /// that does not permit spurious failures. + /// + /// - Parameter expected: The expected current value. + /// - Parameter desired: The desired new 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: A tuple `(exchanged, original)`, where `exchanged` is true if + /// the exchange was successful, and `original` is the original value. + @_semantics("atomics.requires_constant_orderings") + static func atomicCompareExchange( + expected: Value, + desired: __owned Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) + + /// Perform an atomic compare and exchange operation on the value referenced + /// by `pointer`, applying the specified success/failure memory orderings. + /// + /// This operation performs the following algorithm as a single atomic + /// transaction: + /// + /// ``` + /// atomic(self) { currentValue in + /// let original = currentValue + /// guard original == expected else { return (false, original) } + /// currentValue = desired + /// return (true, original) + /// } + /// ``` + /// + /// The `successOrdering` argument specifies the memory ordering to use when + /// the operation manages to update the current value, while `failureOrdering` + /// will be used when the operation leaves the value intact. + /// + /// This method implements a "strong" compare and exchange operation + /// that does not permit spurious failures. + /// + /// - Parameter expected: The expected current value. + /// - Parameter desired: The desired new value. + /// - Parameter pointer: A memory location previously initialized with a value + /// returned by `prepareSelf(for:)`. + /// - Parameter successOrdering: The memory ordering to apply if this + /// operation performs the exchange. + /// - Parameter failureOrdering: The memory ordering to apply on this + /// operation does not perform the exchange. + /// - Returns: A tuple `(exchanged, original)`, where `exchanged` is true if + /// the exchange was successful, and `original` is the original value. + @_semantics("atomics.requires_constant_orderings") + static func atomicCompareExchange( + expected: Value, + desired: __owned Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) + + /// Perform an atomic weak compare and exchange operation on the value + /// referenced by `pointer`, applying the specified success/failure memory + /// orderings. This compare-exchange variant is allowed to spuriously fail; it + /// is designed to be called in a loop until it indicates a successful + /// exchange has happened. + /// + /// This operation performs the following algorithm as a single atomic + /// transaction: + /// + /// ``` + /// atomic(self) { currentValue in + /// let original = currentValue + /// guard original == expected else { return (false, original) } + /// currentValue = desired + /// return (true, original) + /// } + /// ``` + /// + /// (In this weak form, transient conditions may cause the `original == + /// expected` check to sometimes return false when the two values are in fact + /// the same.) + /// + /// The `successOrdering` argument specifies the memory ordering to use when the + /// operation manages to update the current value, while `failureOrdering` + /// will be used when the operation leaves the value intact. + /// + /// - Parameter expected: The expected current value. + /// - Parameter desired: The desired new value. + /// - Parameter pointer: A memory location previously initialized with a value + /// returned by `prepareAtomicRepresentation(for:)`. + /// - Parameter successOrdering: The memory ordering to apply if this + /// operation performs the exchange. + /// - Parameter failureOrdering: The memory ordering to apply on this + /// operation does not perform the exchange. + /// - Returns: A tuple `(exchanged, original)`, where `exchanged` is true if + /// the exchange was successful, and `original` is the original value. + @_semantics("atomics.requires_constant_orderings") + static func atomicWeakCompareExchange( + expected: Value, + desired: __owned Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) +} diff --git a/Sources/Atomics/DoubleWord.swift b/Sources/Atomics/DoubleWord.swift new file mode 100644 index 0000000..ced0115 --- /dev/null +++ b/Sources/Atomics/DoubleWord.swift @@ -0,0 +1,117 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 _AtomicsShims + +public typealias DoubleWord = _AtomicsShims.DoubleWord + +extension DoubleWord { + /// Initialize a new `DoubleWord` value given its high- and + /// low-order words. + @inlinable @inline(__always) + public init(high: UInt, low: UInt) { + self = _sa_dword_create(high, low) + } + + /// Initialize a new `DoubleWord` value given its component words, + /// in the order in which they are laid out in memory. + @inlinable @inline(__always) + public init(first: UInt, second: UInt) { +#if _endian(little) + self = _sa_dword_create(second, first) +#else + self = _sa_dword_create(first, second) +#endif + } + + /// The most significant word in `self`, considering it as a single, + /// wide integer value. This may correspond to either `first` or + /// `second`, depending on the endianness of the underlying + /// architecture. + @inlinable @inline(__always) + public var high: UInt { + get { _sa_dword_extract_high(self) } + set { self = _sa_dword_create(newValue, low) } + } + + /// The least significant word in `self`, considering it as a + /// single, wide integer value. This may correspond to either + /// `first` or `second`, depending on the endianness of the + /// underlying architecture. + @inlinable @inline(__always) + public var low: UInt { + get { _sa_dword_extract_low(self) } + set { self = _sa_dword_create(high, newValue) } + } + + + /// The first word in `self` in its underlying binary + /// representation. + @inlinable @inline(__always) + public var first: UInt { + get { + #if _endian(little) + return _sa_dword_extract_low(self) + #else + return _sa_dword_extract_high(self) + #endif + } + set { + #if _endian(little) + self = _sa_dword_create(high, newValue) + #else + self = _sa_dword_create(newValue, low) + #endif + } + } + + /// The second word in `self` in its underlying binary + /// representation. + @inlinable @inline(__always) + public var second: UInt { + get { + #if _endian(little) + return _sa_dword_extract_high(self) + #else + return _sa_dword_extract_low(self) + #endif + } + set { + #if _endian(little) + self = _sa_dword_create(newValue, low) + #else + self = _sa_dword_create(high, newValue) + #endif + } + } +} + +extension DoubleWord: Equatable { + @inlinable + public static func ==(left: Self, right: Self) -> Bool { + left.high == right.high && left.low == right.low + } +} + +extension DoubleWord: Hashable { + @inlinable + public func hash(into hasher: inout Hasher) { + hasher.combine(self.high) + hasher.combine(self.low) + } +} + +extension DoubleWord: CustomStringConvertible { + public var description: String { + "DoubleWord(high: \(high), low: \(low))" + } +} diff --git a/Sources/Atomics/HighLevelTypes.swift.gyb b/Sources/Atomics/HighLevelTypes.swift.gyb new file mode 100644 index 0000000..63d5bd2 --- /dev/null +++ b/Sources/Atomics/HighLevelTypes.swift.gyb @@ -0,0 +1,366 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// +%{ + from gyb_utils import ( + autogenerated_warning, integerOperations, lowerFirst, argLabel) +}% +${autogenerated_warning()} + +/// An unsafe reference type holding an atomic value, requiring manual memory +/// management of the underlying storage representation. +@frozen +public struct UnsafeAtomic { + public typealias Storage = Value.AtomicRepresentation + + @usableFromInline + internal let _ptr: UnsafeMutablePointer + + /// Initialize an unsafe atomic value that uses the supplied memory location + /// for storage. The storage location must already be initialized to + /// represent a valid atomic value. + /// + /// At the end of the lifetime of the atomic value, you must manually ensure + /// that the storage location is correctly `dispose()`d, deinitalized and + /// deallocated. + /// + /// Note: This is not an atomic operation. + @_transparent // Debug performance + public init( + @_nonEphemeral at pointer: UnsafeMutablePointer + ) { + self._ptr = pointer + } + + /// Create a new `UnsafeAtomic` value with the supplied initial value by + /// dynamically allocating storage for it. + /// + /// This call is usually paired with `destroy` to get rid of the allocated + /// storage at the end of its lifetime. + /// + /// Note: This is not an atomic operation. + @inlinable + public static func create(_ initialValue: __owned Value) -> Self { + let ptr = UnsafeMutablePointer.allocate(capacity: 1) + ptr.initialize(to: Storage(initialValue)) + return Self(at: ptr) + } + + /// Disposes of the current value of the storage location corresponding to + /// this unsafe atomic value, then deinitializes and deallocates the storage. + /// + /// Note: This is not an atomic operation. + /// + /// - Returns: The last value stored in the storage representation before it + /// was destroyed. + @discardableResult + @inlinable + public func destroy() -> Value { + let result = _ptr.pointee.dispose() + _ptr.deinitialize(count: 1) + _ptr.deallocate() + return result + } +} + +/// A reference type holding an atomic value, with automatic memory management. +public class ManagedAtomic { + @usableFromInline + internal var _storage: Value.AtomicRepresentation + + /// Initialize a new managed atomic instance holding the specified initial + /// value. + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + _storage = Value.AtomicRepresentation(value) + } + + deinit { + _ = _storage.dispose() + } + + @_alwaysEmitIntoClient @inline(__always) + internal var _ptr: UnsafeMutablePointer { + _getUnsafePointerToStoredProperties(self) + .assumingMemoryBound(to: Value.AtomicRepresentation.self) + } +} + + +% for type in ["UnsafeAtomic", "ManagedAtomic"]: +extension ${type} { + /// Atomically loads and returns the current value, applying the specified + /// memory ordering. + /// + /// - Parameter ordering: The memory ordering to apply on this operation. + /// - Returns: The current value. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func load( + ordering: AtomicLoadOrdering + ) -> Value { + Value.AtomicRepresentation.atomicLoad(at: _ptr, ordering: ordering) + } + + /// Atomically sets the current value to `desired`, applying the specified + /// memory ordering. + /// + /// - Parameter desired: The desired new value. + /// - Parameter ordering: The memory ordering to apply on this operation. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func store( + _ desired: __owned Value, + ordering: AtomicStoreOrdering + ) { + Value.AtomicRepresentation.atomicStore(desired, at: _ptr, ordering: ordering) + } + + /// Atomically sets the current value to `desired` and returns the original + /// value, applying the specified memory ordering. + /// + /// - Parameter desired: The desired new value. + /// - Parameter ordering: The memory ordering to apply on this operation. + /// - Returns: The original value. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func exchange( + _ desired: __owned Value, + ordering: AtomicUpdateOrdering + ) -> Value { + Value.AtomicRepresentation.atomicExchange(desired, at: _ptr, ordering: ordering) + } + + /// Perform an atomic compare and exchange operation on the current value, + /// applying the specified memory ordering. + /// + /// This operation performs the following algorithm as a single atomic + /// transaction: + /// + /// ``` + /// atomic(self) { currentValue in + /// let original = currentValue + /// guard original == expected else { return (false, original) } + /// currentValue = desired + /// return (true, original) + /// } + /// ``` + /// + /// This method implements a "strong" compare and exchange operation + /// that does not permit spurious failures. + /// + /// - Parameter expected: The expected current value. + /// - Parameter desired: The desired new value. + /// - Parameter ordering: The memory ordering to apply on this operation. + /// - Returns: A tuple `(exchanged, original)`, where `exchanged` is true if + /// the exchange was successful, and `original` is the original value. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func compareExchange( + expected: Value, + desired: __owned Value, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + Value.AtomicRepresentation.atomicCompareExchange( + expected: expected, + desired: desired, + at: _ptr, + ordering: ordering) + } + + /// Perform an atomic compare and exchange operation on the current value, + /// applying the specified success/failure memory orderings. + /// + /// This operation performs the following algorithm as a single atomic + /// transaction: + /// + /// ``` + /// atomic(self) { currentValue in + /// let original = currentValue + /// guard original == expected else { return (false, original) } + /// currentValue = desired + /// return (true, original) + /// } + /// ``` + /// + /// The `succesOrdering` argument specifies the memory ordering to use when + /// the operation manages to update the current value, while `failureOrdering` + /// will be used when the operation leaves the value intact. + /// + /// This method implements a "strong" compare and exchange operation + /// that does not permit spurious failures. + /// + /// - Parameter expected: The expected current value. + /// - Parameter desired: The desired new value. + /// - Parameter successOrdering: The memory ordering to apply if this + /// operation performs the exchange. + /// - Parameter failureOrdering: The memory ordering to apply on this + /// operation does not perform the exchange. + /// - Returns: A tuple `(exchanged, original)`, where `exchanged` is true if + /// the exchange was successful, and `original` is the original value. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func compareExchange( + expected: Value, + desired: __owned Value, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + Value.AtomicRepresentation.atomicCompareExchange( + expected: expected, + desired: desired, + at: _ptr, + successOrdering: successOrdering, + failureOrdering: failureOrdering) + } + + /// Perform an atomic weak compare and exchange operation on the current + /// value, applying the specified success/failure memory orderings. This + /// compare-exchange variant is allowed to spuriously fail; it is designed to + /// be called in a loop until it indicates a successful exchange has happened. + /// + /// This operation performs the following algorithm as a single atomic + /// transaction: + /// + /// ``` + /// atomic(self) { currentValue in + /// let original = currentValue + /// guard original == expected else { return (false, original) } + /// currentValue = desired + /// return (true, original) + /// } + /// ``` + /// + /// (In this weak form, transient conditions may cause the `original == + /// expected` check to sometimes return false when the two values are in fact + /// the same.) + /// + /// The `ordering` argument specifies the memory ordering to use when the + /// operation manages to update the current value, while `failureOrdering` + /// will be used when the operation leaves the value intact. + /// + /// - Parameter expected: The expected current value. + /// - Parameter desired: The desired new value. + /// - Parameter successOrdering: The memory ordering to apply if this + /// operation performs the exchange. + /// - Parameter failureOrdering: The memory ordering to apply on this + /// operation does not perform the exchange. + /// - Returns: A tuple `(exchanged, original)`, where `exchanged` is true if + /// the exchange was successful, and `original` is the original value. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func weakCompareExchange( + expected: Value, + desired: __owned Value, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + Value.AtomicRepresentation.atomicWeakCompareExchange( + expected: expected, + desired: desired, + at: _ptr, + successOrdering: successOrdering, + failureOrdering: failureOrdering) + } +} + +extension ${type} where Value: AtomicInteger { + % for (name, _, op, label, doc) in integerOperations: + /// Perform an atomic ${doc} operation and return the original value, applying + /// the specified memory ordering. + /// + % if "Wrapping" in name: + /// Note: This operation silently wraps around on overflow, like the + /// `${op}` operator does on `Int` values. + /// + % end + /// - Parameter operand: An integer 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${" = 1" if "crement" in name else ""}, + ordering: AtomicUpdateOrdering + ) -> Value { + Value.AtomicRepresentation.atomicLoadThen${name}( + ${argLabel(label)}operand, + at: _ptr, + ordering: ordering) + } + % end + + % for (name, _, op, label, doc) in integerOperations: + /// Perform an atomic ${doc} operation and return the new value, applying + /// the specified memory ordering. + /// + % if "Wrapping" in name: + /// Note: This operation silently wraps around on overflow, like the + /// `${op}` operator does on `Int` values. + /// + % end + /// - Parameter operand: An integer value. + /// - Parameter ordering: The memory ordering to apply on this operation. + /// - Returns: The new value after the operation. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func ${lowerFirst(name)}ThenLoad( + ${label} operand: Value${" = 1" if "crement" in name else ""}, + ordering: AtomicUpdateOrdering + ) -> Value { + let original = Value.AtomicRepresentation.atomicLoadThen${name}( + ${argLabel(label)}operand, + at: _ptr, + ordering: ordering) + return original ${op} operand + } + % end + + /// Perform an atomic wrapping increment operation applying the + /// specified memory ordering. + /// + /// Note: This operation silently wraps around on overflow, like the + /// `&+=` operator does on `Int` values. + /// + /// - Parameter operand: The value to add to the current value. + /// - Parameter ordering: The memory ordering to apply on this operation. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func wrappingIncrement( + by operand: Value = 1, + ordering: AtomicUpdateOrdering + ) { + _ = Value.AtomicRepresentation.atomicLoadThenWrappingIncrement( + by: operand, + at: _ptr, + ordering: ordering) + } + + /// Perform an atomic wrapping decrement operation applying the + /// specified memory ordering. + /// + /// Note: This operation silently wraps around on overflow, like the + /// `&-=` operator does on `Int` values. + /// + /// - Parameter operand: The value to subtract from the current value. + /// - Parameter ordering: The memory ordering to apply on this operation. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func wrappingDecrement( + by operand: Value = 1, + ordering: AtomicUpdateOrdering + ) { + _ = Value.AtomicRepresentation.atomicLoadThenWrappingDecrement( + by: operand, + at: _ptr, + ordering: ordering) + } +} diff --git a/Sources/Atomics/IntegerConformances.swift.gyb b/Sources/Atomics/IntegerConformances.swift.gyb new file mode 100644 index 0000000..9e1b2c7 --- /dev/null +++ b/Sources/Atomics/IntegerConformances.swift.gyb @@ -0,0 +1,222 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// +%{ + from gyb_utils import ( + autogenerated_warning, loadOrderings, storeOrderings, updateOrderings, + integerOperations, lowerFirst, argLabel, shimOrders) + + def atomicTypes(): + return ["Int", "Int64", "Int32", "Int16", "Int8", + "UInt", "UInt64", "UInt32", "UInt16", "UInt8", + "DoubleWord"] +}% +${autogenerated_warning()} + +import _AtomicsShims + +% for swiftType in atomicTypes(): +extension ${swiftType}: AtomicValue { + public struct AtomicRepresentation { + public typealias Value = ${swiftType} + + @usableFromInline + var _storage: _Atomic${swiftType}Storage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = _sa_prepare_${swiftType}(value) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + _sa_dispose_${swiftType}(_storage) + } + } +} + +extension UnsafeMutablePointer +where Pointee == ${swiftType}.AtomicRepresentation { + @inlinable @inline(__always) + internal var _extract: UnsafeMutablePointer<_Atomic${swiftType}Storage> { + // `${swiftType}` is layout-compatible with its only stored property. + return UnsafeMutableRawPointer(self) + .assumingMemoryBound(to: _Atomic${swiftType}Storage.self) + } +} + +extension ${swiftType}.AtomicRepresentation: AtomicStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + switch ordering { +% for (swiftOrder, shimOrder) in loadOrderings: + case .${swiftOrder}: + return _sa_load_${shimOrder}_${swiftType}(pointer._extract) +% end + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + switch ordering { +% for (swiftOrder, shimOrder) in storeOrderings: + case .${swiftOrder}: + _sa_store_${shimOrder}_${swiftType}(pointer._extract, desired) +% end + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { +% for (swiftOrder, shimOrder, _) in updateOrderings: + case .${swiftOrder}: + return _sa_exchange_${shimOrder}_${swiftType}(pointer._extract, desired) +% end + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + var expected = expected + let exchanged: Bool + switch ordering { +% for (swiftOrder, shimOrder, failOrder) in updateOrderings: + case .${swiftOrder}: + exchanged = _sa_cmpxchg_strong_${shimOrder}_${failOrder}_${swiftType}( + pointer._extract, + &expected, desired) +% end + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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)}_${swiftType}( + pointer._extract, + &expected, + desired) +% end +% end + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicWeakCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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)}_${swiftType}( + pointer._extract, + &expected, + desired) +% end +% end + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } +} + +% if swiftType <> "DoubleWord": +extension ${swiftType}: AtomicInteger {} + +extension ${swiftType}.AtomicRepresentation: AtomicIntegerStorage { +% for (name, cname, 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: Value${defaultValue}, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { +% for (swiftOrder, shimOrder, _) in updateOrderings: + case .${swiftOrder}: + return _sa_fetch_${cname}_${shimOrder}_${swiftType}( + pointer._extract, + operand) +% end + default: + fatalError("Unsupported ordering") + } + } +% end +} +% end + +% end diff --git a/Sources/Atomics/PointerConformances.swift.gyb b/Sources/Atomics/PointerConformances.swift.gyb new file mode 100644 index 0000000..9eb4aa1 --- /dev/null +++ b/Sources/Atomics/PointerConformances.swift.gyb @@ -0,0 +1,303 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// + +%{ + from gyb_utils import autogenerated_warning + + atomicTypes = [ + "UnsafeRawPointer", + "UnsafeMutableRawPointer", + "UnsafePointer", + "UnsafeMutablePointer", + "Unmanaged", + ] +}% +${autogenerated_warning()} + +% for swiftType in atomicTypes: +extension ${swiftType}: AtomicValue { + @frozen + public struct AtomicRepresentation { + public typealias Value = ${swiftType} + @usableFromInline internal typealias Storage = Int.AtomicRepresentation + + @usableFromInline + internal let _storage: Storage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = .init(Self._encode(value)) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + Self._decode(_storage.dispose()) + } + } +} + +extension ${swiftType}.AtomicRepresentation { + @_transparent @_alwaysEmitIntoClient + @usableFromInline + internal static func _extract( + _ ptr: UnsafeMutablePointer + ) -> UnsafeMutablePointer { + // `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, + ordering: AtomicLoadOrdering + ) -> Value { + let encoded = Storage.atomicLoad(at: _extract(pointer), ordering: ordering) + return _decode(encoded) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + Storage.atomicStore(_encode(desired), at: _extract(pointer), ordering: ordering) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + _decode(Storage.atomicExchange(_encode(desired), at: _extract(pointer), ordering: ordering)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + ordering: ordering) + return (exchanged, _decode(original)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + 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, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicWeakCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + successOrdering: successOrdering, + failureOrdering: failureOrdering) + return (exchanged, _decode(original)) + } +} +% end + + +% for swiftType in atomicTypes: +extension ${swiftType}: AtomicOptionalWrappable { + @frozen + public struct AtomicOptionalRepresentation { + public typealias Value = ${swiftType}? + @usableFromInline internal typealias Storage = Int.AtomicRepresentation + + @usableFromInline + internal let _storage: Storage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = .init(Self._encode(value)) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + Self._decode(_storage.dispose()) + } + } +} + +extension ${swiftType}.AtomicOptionalRepresentation { + @_transparent @_alwaysEmitIntoClient + @usableFromInline + internal static func _extract( + _ ptr: UnsafeMutablePointer + ) -> UnsafeMutablePointer { + // `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, + ordering: AtomicLoadOrdering + ) -> Value { + let encoded = Storage.atomicLoad(at: _extract(pointer), ordering: ordering) + return _decode(encoded) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + Storage.atomicStore(_encode(desired), at: _extract(pointer), ordering: ordering) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + _decode(Storage.atomicExchange(_encode(desired), at: _extract(pointer), ordering: ordering)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + ordering: ordering) + return (exchanged, _decode(original)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + 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, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicWeakCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + successOrdering: successOrdering, + failureOrdering: failureOrdering) + return (exchanged, _decode(original)) + } +} +% end diff --git a/Sources/Atomics/autogenerated/AtomicBool.swift b/Sources/Atomics/autogenerated/AtomicBool.swift new file mode 100644 index 0000000..bbff151 --- /dev/null +++ b/Sources/Atomics/autogenerated/AtomicBool.swift @@ -0,0 +1,694 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// + + +// ############################################################################# +// # # +// # DO NOT EDIT THIS FILE; IT IS AUTOGENERATED. # +// # # +// ############################################################################# + + +import _AtomicsShims + +extension Bool: AtomicValue { + 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 + ) -> 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, + ordering: AtomicLoadOrdering + ) -> Bool { + switch ordering { + case .relaxed: + return _sa_load_relaxed_Bool(_extract(pointer)) + case .acquiring: + return _sa_load_acquire_Bool(_extract(pointer)) + case .sequentiallyConsistent: + return _sa_load_seq_cst_Bool(_extract(pointer)) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: __owned Bool, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + switch ordering { + case .relaxed: + _sa_store_relaxed_Bool(_extract(pointer), desired) + case .releasing: + _sa_store_release_Bool(_extract(pointer), desired) + case .sequentiallyConsistent: + _sa_store_seq_cst_Bool(_extract(pointer), desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: __owned Bool, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Bool { + switch ordering { + case .relaxed: + return _sa_exchange_relaxed_Bool(_extract(pointer), desired) + case .acquiring: + return _sa_exchange_acquire_Bool(_extract(pointer), desired) + case .releasing: + return _sa_exchange_release_Bool(_extract(pointer), desired) + case .acquiringAndReleasing: + return _sa_exchange_acq_rel_Bool(_extract(pointer), desired) + case .sequentiallyConsistent: + return _sa_exchange_seq_cst_Bool(_extract(pointer), desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Bool, + desired: __owned Bool, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Bool) { + var expected = expected + let exchanged: Bool + switch ordering { + case .relaxed: + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_Bool( + _extract(pointer), + &expected, desired) + case .acquiring: + exchanged = _sa_cmpxchg_strong_acquire_acquire_Bool( + _extract(pointer), + &expected, desired) + case .releasing: + exchanged = _sa_cmpxchg_strong_release_relaxed_Bool( + _extract(pointer), + &expected, desired) + case .acquiringAndReleasing: + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_Bool( + _extract(pointer), + &expected, desired) + case .sequentiallyConsistent: + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Bool( + _extract(pointer), + &expected, desired) + 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, + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_Bool( + _extract(pointer), + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_Bool( + _extract(pointer), + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Bool( + _extract(pointer), + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_strong_acquire_relaxed_Bool( + _extract(pointer), + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_Bool( + _extract(pointer), + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Bool( + _extract(pointer), + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_strong_release_relaxed_Bool( + _extract(pointer), + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_Bool( + _extract(pointer), + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Bool( + _extract(pointer), + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_strong_acq_rel_relaxed_Bool( + _extract(pointer), + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_Bool( + _extract(pointer), + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Bool( + _extract(pointer), + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_strong_seq_cst_relaxed_Bool( + _extract(pointer), + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_strong_seq_cst_acquire_Bool( + _extract(pointer), + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Bool( + _extract(pointer), + &expected, + desired) + 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, + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_weak_relaxed_relaxed_Bool( + _extract(pointer), + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_Bool( + _extract(pointer), + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Bool( + _extract(pointer), + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_weak_acquire_relaxed_Bool( + _extract(pointer), + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_Bool( + _extract(pointer), + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Bool( + _extract(pointer), + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_weak_release_relaxed_Bool( + _extract(pointer), + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_Bool( + _extract(pointer), + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Bool( + _extract(pointer), + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_weak_acq_rel_relaxed_Bool( + _extract(pointer), + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_Bool( + _extract(pointer), + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Bool( + _extract(pointer), + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_weak_seq_cst_relaxed_Bool( + _extract(pointer), + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_weak_seq_cst_acquire_Bool( + _extract(pointer), + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Bool( + _extract(pointer), + &expected, + desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } +} + + +// MARK: - Additional operations + +extension Bool.AtomicRepresentation { + /// Perform an atomic logical AND 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 + static func atomicLoadThenLogicalAnd( + with operand: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_and_relaxed_Bool( + _extract(pointer), + operand) + case .acquiring: + return _sa_fetch_and_acquire_Bool( + _extract(pointer), + operand) + case .releasing: + return _sa_fetch_and_release_Bool( + _extract(pointer), + operand) + case .acquiringAndReleasing: + return _sa_fetch_and_acq_rel_Bool( + _extract(pointer), + operand) + case .sequentiallyConsistent: + return _sa_fetch_and_seq_cst_Bool( + _extract(pointer), + operand) + default: + fatalError("Unsupported ordering") + } + } + /// Perform an atomic logical OR 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 + static func atomicLoadThenLogicalOr( + with operand: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_or_relaxed_Bool( + _extract(pointer), + operand) + case .acquiring: + return _sa_fetch_or_acquire_Bool( + _extract(pointer), + operand) + case .releasing: + return _sa_fetch_or_release_Bool( + _extract(pointer), + operand) + case .acquiringAndReleasing: + return _sa_fetch_or_acq_rel_Bool( + _extract(pointer), + operand) + case .sequentiallyConsistent: + return _sa_fetch_or_seq_cst_Bool( + _extract(pointer), + operand) + default: + fatalError("Unsupported ordering") + } + } + /// Perform an atomic logical XOR 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 + static func atomicLoadThenLogicalXor( + with operand: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_xor_relaxed_Bool( + _extract(pointer), + operand) + case .acquiring: + return _sa_fetch_xor_acquire_Bool( + _extract(pointer), + operand) + case .releasing: + return _sa_fetch_xor_release_Bool( + _extract(pointer), + operand) + case .acquiringAndReleasing: + return _sa_fetch_xor_acq_rel_Bool( + _extract(pointer), + operand) + case .sequentiallyConsistent: + return _sa_fetch_xor_seq_cst_Bool( + _extract(pointer), + operand) + default: + fatalError("Unsupported ordering") + } + } +} + +extension UnsafeAtomic where Value == Bool { + /// Perform an atomic logical AND 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 loadThenLogicalAnd( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + Value.AtomicRepresentation.atomicLoadThenLogicalAnd( + with: operand, + at: _ptr, + ordering: ordering) + } + /// Perform an atomic logical OR 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 loadThenLogicalOr( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + Value.AtomicRepresentation.atomicLoadThenLogicalOr( + with: operand, + at: _ptr, + ordering: ordering) + } + /// Perform an atomic logical XOR 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 loadThenLogicalXor( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + Value.AtomicRepresentation.atomicLoadThenLogicalXor( + with: operand, + at: _ptr, + ordering: ordering) + } +} + +extension UnsafeAtomic where Value == Bool { + /// Perform an atomic logical AND 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 logicalAndThenLoad( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + let original = Value.AtomicRepresentation.atomicLoadThenLogicalAnd( + with: operand, + at: _ptr, + ordering: ordering) + return original && operand + } + /// Perform an atomic logical OR 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 logicalOrThenLoad( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + let original = Value.AtomicRepresentation.atomicLoadThenLogicalOr( + with: operand, + at: _ptr, + ordering: ordering) + return original || operand + } + /// Perform an atomic logical XOR 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 logicalXorThenLoad( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + let original = Value.AtomicRepresentation.atomicLoadThenLogicalXor( + with: operand, + at: _ptr, + ordering: ordering) + return original != operand + } +} +extension ManagedAtomic where Value == Bool { + /// Perform an atomic logical AND 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 loadThenLogicalAnd( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + Value.AtomicRepresentation.atomicLoadThenLogicalAnd( + with: operand, + at: _ptr, + ordering: ordering) + } + /// Perform an atomic logical OR 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 loadThenLogicalOr( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + Value.AtomicRepresentation.atomicLoadThenLogicalOr( + with: operand, + at: _ptr, + ordering: ordering) + } + /// Perform an atomic logical XOR 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 loadThenLogicalXor( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + Value.AtomicRepresentation.atomicLoadThenLogicalXor( + with: operand, + at: _ptr, + ordering: ordering) + } +} + +extension ManagedAtomic where Value == Bool { + /// Perform an atomic logical AND 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 logicalAndThenLoad( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + let original = Value.AtomicRepresentation.atomicLoadThenLogicalAnd( + with: operand, + at: _ptr, + ordering: ordering) + return original && operand + } + /// Perform an atomic logical OR 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 logicalOrThenLoad( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + let original = Value.AtomicRepresentation.atomicLoadThenLogicalOr( + with: operand, + at: _ptr, + ordering: ordering) + return original || operand + } + /// Perform an atomic logical XOR 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 logicalXorThenLoad( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + let original = Value.AtomicRepresentation.atomicLoadThenLogicalXor( + with: operand, + at: _ptr, + ordering: ordering) + return original != operand + } +} diff --git a/Sources/Atomics/autogenerated/AtomicLazyReference.swift b/Sources/Atomics/autogenerated/AtomicLazyReference.swift new file mode 100644 index 0000000..2dac71d --- /dev/null +++ b/Sources/Atomics/autogenerated/AtomicLazyReference.swift @@ -0,0 +1,251 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// + +// ############################################################################# +// # # +// # DO NOT EDIT THIS FILE; IT IS AUTOGENERATED. # +// # # +// ############################################################################# + + +/// An unsafe reference type holding a lazily initializable atomic +/// strong reference, requiring manual memory management of the +/// underlying storage representation. +/// +/// These values can be set (initialized) exactly once, but read many +/// times. +@frozen +public struct UnsafeAtomicLazyReference { + /// The value logically stored in an atomic lazy reference value. + public typealias Value = Instance? + + @usableFromInline + internal typealias _Rep = Optional>.AtomicRepresentation + + @usableFromInline + internal let _ptr: UnsafeMutablePointer<_Rep> + + /// Initialize an unsafe atomic lazy reference that uses the supplied memory + /// location for storage. The storage location must already be initialized to + /// represent a valid atomic value. + /// + /// At the end of the lifetime of the atomic value, you must manually ensure + /// that the storage location is correctly `dispose()`d, deinitalized and + /// deallocated. + /// + /// Note: This is not an atomic operation. + @_transparent // Debug performance + public init(@_nonEphemeral at pointer: UnsafeMutablePointer) { + // `Storage` is layout-compatible with its only stored property. + _ptr = UnsafeMutableRawPointer(pointer).assumingMemoryBound(to: _Rep.self) + } +} + +extension UnsafeAtomicLazyReference { + /// The storage representation for an atomic lazy reference value. + @frozen + public struct Storage { + @usableFromInline + internal var _storage: _Rep + + /// Initialize a new atomic lazy reference storage value holding `nil`. + /// + /// Note: This is not an atomic operation. This call may have side effects + /// (such as unpaired retains of strong references) that will need to be + /// undone by calling `dispose()` before the storage value is + /// deinitialized. + @inlinable @inline(__always) + public init() { + _storage = _Rep(nil) + } + + /// Prepare this atomic storage value for deinitialization, extracting the + /// logical value it represents. This invalidates this atomic storage; you + /// must not perform any operations on it after this call (except for + /// deinitialization). + /// + /// This call prevents resource leaks when destroying the storage + /// representation of certain `AtomicValue` types. (In particular, ones + /// that model strong references.) + /// + /// Note: This is not an atomic operation. Logically, it implements a + /// custom destructor for the underlying non-copiable value. + @inlinable @inline(__always) + @discardableResult + public mutating func dispose() -> Value { + defer { _storage = _Rep(nil) } + return _storage.dispose()?.takeRetainedValue() + } + } +} + +extension UnsafeAtomicLazyReference { + /// Create a new `UnsafeAtomicLazyReference` value by dynamically allocating + /// storage for it. + /// + /// This call is usually paired with `destroy` to get rid of the allocated + /// storage at the end of its lifetime. + /// + /// Note: This is not an atomic operation. + @inlinable + public static func create() -> Self { + let ptr = UnsafeMutablePointer.allocate(capacity: 1) + ptr.initialize(to: Storage()) + return Self(at: ptr) + } + + /// Disposes of the current value of the storage location corresponding to + /// this unsafe atomic lazy reference, then deinitializes and deallocates the + /// storage. + /// + /// Note: This is not an atomic operation. + /// + /// - Returns: The last value stored in the storage representation before it + /// was destroyed. + @discardableResult + @inlinable + public func destroy() -> Value { + // `Storage` is layout-compatible with its only stored property. + let address = UnsafeMutableRawPointer(_ptr) + .assumingMemoryBound(to: Storage.self) + defer { address.deallocate() } + return address.pointee.dispose() + } +} + +/// A reference type holding a lazily initializable atomic +/// strong reference, with automatic memory management. +/// +/// These values can be set (initialized) exactly once, but read many +/// times. +public class ManagedAtomicLazyReference { + /// The value logically stored in an atomic lazy reference value. + public typealias Value = Instance? + + @usableFromInline + internal typealias _Rep = Optional>.AtomicRepresentation + + @usableFromInline + internal let _storage: _Rep + + /// Initializes a new managed atomic lazy reference with a nil value. + @inlinable + public init() { + _storage = _Rep(nil) + } + + @_alwaysEmitIntoClient @inline(__always) + internal var _ptr: UnsafeMutablePointer<_Rep> { + _getUnsafePointerToStoredProperties(self).assumingMemoryBound(to: _Rep.self) + } +} + +extension UnsafeAtomicLazyReference { + /// Atomically initializes this reference if its current value is nil, then + /// returns the initialized value. If this reference is already initialized, + /// then `storeIfNilThenLoad(_:)` discards its supplied argument and returns + /// the current value without updating it. + /// + /// The following example demonstrates how this can be used to implement a + /// thread-safe lazily initialized reference: + /// + /// ``` + /// class Image { + /// var _histogram: UnsafeAtomicLazyReference = ... + /// + /// // This is safe to call concurrently from multiple threads. + /// var atomicLazyHistogram: Histogram { + /// if let histogram = _histogram.load() { return foo } + /// // Note that code here may run concurrently on + /// // multiple threads, but only one of them will get to + /// // succeed setting the reference. + /// let histogram = ... + /// return _histogram.storeIfNilThenLoad(foo) + /// } + /// ``` + /// + /// This operation uses acquiring-and-releasing memory ordering. + public func storeIfNilThenLoad(_ desired: __owned Instance) -> Instance { + let desiredUnmanaged = Unmanaged.passRetained(desired) + let (exchanged, current) = _Rep.atomicCompareExchange( + expected: nil, + desired: desiredUnmanaged, + at: _ptr, + ordering: .acquiringAndReleasing) + if !exchanged { + // The reference has already been initialized. Balance the retain that + // we performed on `desired`. + desiredUnmanaged.release() + return current!.takeUnretainedValue() + } + return desiredUnmanaged.takeUnretainedValue() + } + + /// Atomically loads and returns the current value of this reference. + /// + /// The load operation is performed with the memory ordering + /// `AtomicLoadOrdering.acquiring`. + public func load() -> Instance? { + let value = _Rep.atomicLoad(at: _ptr, ordering: .acquiring) + return value?.takeUnretainedValue() + } +} +extension ManagedAtomicLazyReference { + /// Atomically initializes this reference if its current value is nil, then + /// returns the initialized value. If this reference is already initialized, + /// then `storeIfNilThenLoad(_:)` discards its supplied argument and returns + /// the current value without updating it. + /// + /// The following example demonstrates how this can be used to implement a + /// thread-safe lazily initialized reference: + /// + /// ``` + /// class Image { + /// var _histogram: UnsafeAtomicLazyReference = ... + /// + /// // This is safe to call concurrently from multiple threads. + /// var atomicLazyHistogram: Histogram { + /// if let histogram = _histogram.load() { return foo } + /// // Note that code here may run concurrently on + /// // multiple threads, but only one of them will get to + /// // succeed setting the reference. + /// let histogram = ... + /// return _histogram.storeIfNilThenLoad(foo) + /// } + /// ``` + /// + /// This operation uses acquiring-and-releasing memory ordering. + public func storeIfNilThenLoad(_ desired: __owned Instance) -> Instance { + let desiredUnmanaged = Unmanaged.passRetained(desired) + let (exchanged, current) = _Rep.atomicCompareExchange( + expected: nil, + desired: desiredUnmanaged, + at: _ptr, + ordering: .acquiringAndReleasing) + if !exchanged { + // The reference has already been initialized. Balance the retain that + // we performed on `desired`. + desiredUnmanaged.release() + return current!.takeUnretainedValue() + } + return desiredUnmanaged.takeUnretainedValue() + } + + /// Atomically loads and returns the current value of this reference. + /// + /// The load operation is performed with the memory ordering + /// `AtomicLoadOrdering.acquiring`. + public func load() -> Instance? { + let value = _Rep.atomicLoad(at: _ptr, ordering: .acquiring) + return value?.takeUnretainedValue() + } +} diff --git a/Sources/Atomics/autogenerated/HighLevelTypes.swift b/Sources/Atomics/autogenerated/HighLevelTypes.swift new file mode 100644 index 0000000..b0c2c35 --- /dev/null +++ b/Sources/Atomics/autogenerated/HighLevelTypes.swift @@ -0,0 +1,911 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// + +// ############################################################################# +// # # +// # DO NOT EDIT THIS FILE; IT IS AUTOGENERATED. # +// # # +// ############################################################################# + + +/// An unsafe reference type holding an atomic value, requiring manual memory +/// management of the underlying storage representation. +@frozen +public struct UnsafeAtomic { + public typealias Storage = Value.AtomicRepresentation + + @usableFromInline + internal let _ptr: UnsafeMutablePointer + + /// Initialize an unsafe atomic value that uses the supplied memory location + /// for storage. The storage location must already be initialized to + /// represent a valid atomic value. + /// + /// At the end of the lifetime of the atomic value, you must manually ensure + /// that the storage location is correctly `dispose()`d, deinitalized and + /// deallocated. + /// + /// Note: This is not an atomic operation. + @_transparent // Debug performance + public init( + @_nonEphemeral at pointer: UnsafeMutablePointer + ) { + self._ptr = pointer + } + + /// Create a new `UnsafeAtomic` value with the supplied initial value by + /// dynamically allocating storage for it. + /// + /// This call is usually paired with `destroy` to get rid of the allocated + /// storage at the end of its lifetime. + /// + /// Note: This is not an atomic operation. + @inlinable + public static func create(_ initialValue: __owned Value) -> Self { + let ptr = UnsafeMutablePointer.allocate(capacity: 1) + ptr.initialize(to: Storage(initialValue)) + return Self(at: ptr) + } + + /// Disposes of the current value of the storage location corresponding to + /// this unsafe atomic value, then deinitializes and deallocates the storage. + /// + /// Note: This is not an atomic operation. + /// + /// - Returns: The last value stored in the storage representation before it + /// was destroyed. + @discardableResult + @inlinable + public func destroy() -> Value { + let result = _ptr.pointee.dispose() + _ptr.deinitialize(count: 1) + _ptr.deallocate() + return result + } +} + +/// A reference type holding an atomic value, with automatic memory management. +public class ManagedAtomic { + @usableFromInline + internal var _storage: Value.AtomicRepresentation + + /// Initialize a new managed atomic instance holding the specified initial + /// value. + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + _storage = Value.AtomicRepresentation(value) + } + + deinit { + _ = _storage.dispose() + } + + @_alwaysEmitIntoClient @inline(__always) + internal var _ptr: UnsafeMutablePointer { + _getUnsafePointerToStoredProperties(self) + .assumingMemoryBound(to: Value.AtomicRepresentation.self) + } +} + + +extension UnsafeAtomic { + /// Atomically loads and returns the current value, applying the specified + /// memory ordering. + /// + /// - Parameter ordering: The memory ordering to apply on this operation. + /// - Returns: The current value. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func load( + ordering: AtomicLoadOrdering + ) -> Value { + Value.AtomicRepresentation.atomicLoad(at: _ptr, ordering: ordering) + } + + /// Atomically sets the current value to `desired`, applying the specified + /// memory ordering. + /// + /// - Parameter desired: The desired new value. + /// - Parameter ordering: The memory ordering to apply on this operation. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func store( + _ desired: __owned Value, + ordering: AtomicStoreOrdering + ) { + Value.AtomicRepresentation.atomicStore(desired, at: _ptr, ordering: ordering) + } + + /// Atomically sets the current value to `desired` and returns the original + /// value, applying the specified memory ordering. + /// + /// - Parameter desired: The desired new value. + /// - Parameter ordering: The memory ordering to apply on this operation. + /// - Returns: The original value. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func exchange( + _ desired: __owned Value, + ordering: AtomicUpdateOrdering + ) -> Value { + Value.AtomicRepresentation.atomicExchange(desired, at: _ptr, ordering: ordering) + } + + /// Perform an atomic compare and exchange operation on the current value, + /// applying the specified memory ordering. + /// + /// This operation performs the following algorithm as a single atomic + /// transaction: + /// + /// ``` + /// atomic(self) { currentValue in + /// let original = currentValue + /// guard original == expected else { return (false, original) } + /// currentValue = desired + /// return (true, original) + /// } + /// ``` + /// + /// This method implements a "strong" compare and exchange operation + /// that does not permit spurious failures. + /// + /// - Parameter expected: The expected current value. + /// - Parameter desired: The desired new value. + /// - Parameter ordering: The memory ordering to apply on this operation. + /// - Returns: A tuple `(exchanged, original)`, where `exchanged` is true if + /// the exchange was successful, and `original` is the original value. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func compareExchange( + expected: Value, + desired: __owned Value, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + Value.AtomicRepresentation.atomicCompareExchange( + expected: expected, + desired: desired, + at: _ptr, + ordering: ordering) + } + + /// Perform an atomic compare and exchange operation on the current value, + /// applying the specified success/failure memory orderings. + /// + /// This operation performs the following algorithm as a single atomic + /// transaction: + /// + /// ``` + /// atomic(self) { currentValue in + /// let original = currentValue + /// guard original == expected else { return (false, original) } + /// currentValue = desired + /// return (true, original) + /// } + /// ``` + /// + /// The `succesOrdering` argument specifies the memory ordering to use when + /// the operation manages to update the current value, while `failureOrdering` + /// will be used when the operation leaves the value intact. + /// + /// This method implements a "strong" compare and exchange operation + /// that does not permit spurious failures. + /// + /// - Parameter expected: The expected current value. + /// - Parameter desired: The desired new value. + /// - Parameter successOrdering: The memory ordering to apply if this + /// operation performs the exchange. + /// - Parameter failureOrdering: The memory ordering to apply on this + /// operation does not perform the exchange. + /// - Returns: A tuple `(exchanged, original)`, where `exchanged` is true if + /// the exchange was successful, and `original` is the original value. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func compareExchange( + expected: Value, + desired: __owned Value, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + Value.AtomicRepresentation.atomicCompareExchange( + expected: expected, + desired: desired, + at: _ptr, + successOrdering: successOrdering, + failureOrdering: failureOrdering) + } + + /// Perform an atomic weak compare and exchange operation on the current + /// value, applying the specified success/failure memory orderings. This + /// compare-exchange variant is allowed to spuriously fail; it is designed to + /// be called in a loop until it indicates a successful exchange has happened. + /// + /// This operation performs the following algorithm as a single atomic + /// transaction: + /// + /// ``` + /// atomic(self) { currentValue in + /// let original = currentValue + /// guard original == expected else { return (false, original) } + /// currentValue = desired + /// return (true, original) + /// } + /// ``` + /// + /// (In this weak form, transient conditions may cause the `original == + /// expected` check to sometimes return false when the two values are in fact + /// the same.) + /// + /// The `ordering` argument specifies the memory ordering to use when the + /// operation manages to update the current value, while `failureOrdering` + /// will be used when the operation leaves the value intact. + /// + /// - Parameter expected: The expected current value. + /// - Parameter desired: The desired new value. + /// - Parameter successOrdering: The memory ordering to apply if this + /// operation performs the exchange. + /// - Parameter failureOrdering: The memory ordering to apply on this + /// operation does not perform the exchange. + /// - Returns: A tuple `(exchanged, original)`, where `exchanged` is true if + /// the exchange was successful, and `original` is the original value. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func weakCompareExchange( + expected: Value, + desired: __owned Value, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + Value.AtomicRepresentation.atomicWeakCompareExchange( + expected: expected, + desired: desired, + at: _ptr, + successOrdering: successOrdering, + failureOrdering: failureOrdering) + } +} + +extension UnsafeAtomic where Value: AtomicInteger { + /// Perform an atomic wrapping add operation and return the original value, applying + /// the specified memory ordering. + /// + /// Note: This operation silently wraps around on overflow, like the + /// `&+` operator does on `Int` values. + /// + /// - Parameter operand: An integer 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 loadThenWrappingIncrement( + by operand: Value = 1, + ordering: AtomicUpdateOrdering + ) -> Value { + Value.AtomicRepresentation.atomicLoadThenWrappingIncrement( + by: operand, + at: _ptr, + ordering: ordering) + } + /// Perform an atomic wrapping subtract operation and return the original value, applying + /// the specified memory ordering. + /// + /// Note: This operation silently wraps around on overflow, like the + /// `&-` operator does on `Int` values. + /// + /// - Parameter operand: An integer 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 loadThenWrappingDecrement( + by operand: Value = 1, + ordering: AtomicUpdateOrdering + ) -> Value { + Value.AtomicRepresentation.atomicLoadThenWrappingDecrement( + by: operand, + at: _ptr, + ordering: ordering) + } + /// Perform an atomic bitwise AND operation and return the original value, applying + /// the specified memory ordering. + /// + /// - Parameter operand: An integer 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 loadThenBitwiseAnd( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + Value.AtomicRepresentation.atomicLoadThenBitwiseAnd( + with: operand, + at: _ptr, + ordering: ordering) + } + /// Perform an atomic bitwise OR operation and return the original value, applying + /// the specified memory ordering. + /// + /// - Parameter operand: An integer 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 loadThenBitwiseOr( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + Value.AtomicRepresentation.atomicLoadThenBitwiseOr( + with: operand, + at: _ptr, + ordering: ordering) + } + /// Perform an atomic bitwise XOR operation and return the original value, applying + /// the specified memory ordering. + /// + /// - Parameter operand: An integer 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 loadThenBitwiseXor( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + Value.AtomicRepresentation.atomicLoadThenBitwiseXor( + with: operand, + at: _ptr, + ordering: ordering) + } + + /// Perform an atomic wrapping add operation and return the new value, applying + /// the specified memory ordering. + /// + /// Note: This operation silently wraps around on overflow, like the + /// `&+` operator does on `Int` values. + /// + /// - Parameter operand: An integer value. + /// - Parameter ordering: The memory ordering to apply on this operation. + /// - Returns: The new value after the operation. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func wrappingIncrementThenLoad( + by operand: Value = 1, + ordering: AtomicUpdateOrdering + ) -> Value { + let original = Value.AtomicRepresentation.atomicLoadThenWrappingIncrement( + by: operand, + at: _ptr, + ordering: ordering) + return original &+ operand + } + /// Perform an atomic wrapping subtract operation and return the new value, applying + /// the specified memory ordering. + /// + /// Note: This operation silently wraps around on overflow, like the + /// `&-` operator does on `Int` values. + /// + /// - Parameter operand: An integer value. + /// - Parameter ordering: The memory ordering to apply on this operation. + /// - Returns: The new value after the operation. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func wrappingDecrementThenLoad( + by operand: Value = 1, + ordering: AtomicUpdateOrdering + ) -> Value { + let original = Value.AtomicRepresentation.atomicLoadThenWrappingDecrement( + by: operand, + at: _ptr, + ordering: ordering) + return original &- operand + } + /// Perform an atomic bitwise AND operation and return the new value, applying + /// the specified memory ordering. + /// + /// - Parameter operand: An integer value. + /// - Parameter ordering: The memory ordering to apply on this operation. + /// - Returns: The new value after the operation. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func bitwiseAndThenLoad( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + let original = Value.AtomicRepresentation.atomicLoadThenBitwiseAnd( + with: operand, + at: _ptr, + ordering: ordering) + return original & operand + } + /// Perform an atomic bitwise OR operation and return the new value, applying + /// the specified memory ordering. + /// + /// - Parameter operand: An integer value. + /// - Parameter ordering: The memory ordering to apply on this operation. + /// - Returns: The new value after the operation. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func bitwiseOrThenLoad( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + let original = Value.AtomicRepresentation.atomicLoadThenBitwiseOr( + with: operand, + at: _ptr, + ordering: ordering) + return original | operand + } + /// Perform an atomic bitwise XOR operation and return the new value, applying + /// the specified memory ordering. + /// + /// - Parameter operand: An integer value. + /// - Parameter ordering: The memory ordering to apply on this operation. + /// - Returns: The new value after the operation. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func bitwiseXorThenLoad( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + let original = Value.AtomicRepresentation.atomicLoadThenBitwiseXor( + with: operand, + at: _ptr, + ordering: ordering) + return original ^ operand + } + + /// Perform an atomic wrapping increment operation applying the + /// specified memory ordering. + /// + /// Note: This operation silently wraps around on overflow, like the + /// `&+=` operator does on `Int` values. + /// + /// - Parameter operand: The value to add to the current value. + /// - Parameter ordering: The memory ordering to apply on this operation. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func wrappingIncrement( + by operand: Value = 1, + ordering: AtomicUpdateOrdering + ) { + _ = Value.AtomicRepresentation.atomicLoadThenWrappingIncrement( + by: operand, + at: _ptr, + ordering: ordering) + } + + /// Perform an atomic wrapping decrement operation applying the + /// specified memory ordering. + /// + /// Note: This operation silently wraps around on overflow, like the + /// `&-=` operator does on `Int` values. + /// + /// - Parameter operand: The value to subtract from the current value. + /// - Parameter ordering: The memory ordering to apply on this operation. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func wrappingDecrement( + by operand: Value = 1, + ordering: AtomicUpdateOrdering + ) { + _ = Value.AtomicRepresentation.atomicLoadThenWrappingDecrement( + by: operand, + at: _ptr, + ordering: ordering) + } +} +extension ManagedAtomic { + /// Atomically loads and returns the current value, applying the specified + /// memory ordering. + /// + /// - Parameter ordering: The memory ordering to apply on this operation. + /// - Returns: The current value. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func load( + ordering: AtomicLoadOrdering + ) -> Value { + Value.AtomicRepresentation.atomicLoad(at: _ptr, ordering: ordering) + } + + /// Atomically sets the current value to `desired`, applying the specified + /// memory ordering. + /// + /// - Parameter desired: The desired new value. + /// - Parameter ordering: The memory ordering to apply on this operation. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func store( + _ desired: __owned Value, + ordering: AtomicStoreOrdering + ) { + Value.AtomicRepresentation.atomicStore(desired, at: _ptr, ordering: ordering) + } + + /// Atomically sets the current value to `desired` and returns the original + /// value, applying the specified memory ordering. + /// + /// - Parameter desired: The desired new value. + /// - Parameter ordering: The memory ordering to apply on this operation. + /// - Returns: The original value. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func exchange( + _ desired: __owned Value, + ordering: AtomicUpdateOrdering + ) -> Value { + Value.AtomicRepresentation.atomicExchange(desired, at: _ptr, ordering: ordering) + } + + /// Perform an atomic compare and exchange operation on the current value, + /// applying the specified memory ordering. + /// + /// This operation performs the following algorithm as a single atomic + /// transaction: + /// + /// ``` + /// atomic(self) { currentValue in + /// let original = currentValue + /// guard original == expected else { return (false, original) } + /// currentValue = desired + /// return (true, original) + /// } + /// ``` + /// + /// This method implements a "strong" compare and exchange operation + /// that does not permit spurious failures. + /// + /// - Parameter expected: The expected current value. + /// - Parameter desired: The desired new value. + /// - Parameter ordering: The memory ordering to apply on this operation. + /// - Returns: A tuple `(exchanged, original)`, where `exchanged` is true if + /// the exchange was successful, and `original` is the original value. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func compareExchange( + expected: Value, + desired: __owned Value, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + Value.AtomicRepresentation.atomicCompareExchange( + expected: expected, + desired: desired, + at: _ptr, + ordering: ordering) + } + + /// Perform an atomic compare and exchange operation on the current value, + /// applying the specified success/failure memory orderings. + /// + /// This operation performs the following algorithm as a single atomic + /// transaction: + /// + /// ``` + /// atomic(self) { currentValue in + /// let original = currentValue + /// guard original == expected else { return (false, original) } + /// currentValue = desired + /// return (true, original) + /// } + /// ``` + /// + /// The `succesOrdering` argument specifies the memory ordering to use when + /// the operation manages to update the current value, while `failureOrdering` + /// will be used when the operation leaves the value intact. + /// + /// This method implements a "strong" compare and exchange operation + /// that does not permit spurious failures. + /// + /// - Parameter expected: The expected current value. + /// - Parameter desired: The desired new value. + /// - Parameter successOrdering: The memory ordering to apply if this + /// operation performs the exchange. + /// - Parameter failureOrdering: The memory ordering to apply on this + /// operation does not perform the exchange. + /// - Returns: A tuple `(exchanged, original)`, where `exchanged` is true if + /// the exchange was successful, and `original` is the original value. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func compareExchange( + expected: Value, + desired: __owned Value, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + Value.AtomicRepresentation.atomicCompareExchange( + expected: expected, + desired: desired, + at: _ptr, + successOrdering: successOrdering, + failureOrdering: failureOrdering) + } + + /// Perform an atomic weak compare and exchange operation on the current + /// value, applying the specified success/failure memory orderings. This + /// compare-exchange variant is allowed to spuriously fail; it is designed to + /// be called in a loop until it indicates a successful exchange has happened. + /// + /// This operation performs the following algorithm as a single atomic + /// transaction: + /// + /// ``` + /// atomic(self) { currentValue in + /// let original = currentValue + /// guard original == expected else { return (false, original) } + /// currentValue = desired + /// return (true, original) + /// } + /// ``` + /// + /// (In this weak form, transient conditions may cause the `original == + /// expected` check to sometimes return false when the two values are in fact + /// the same.) + /// + /// The `ordering` argument specifies the memory ordering to use when the + /// operation manages to update the current value, while `failureOrdering` + /// will be used when the operation leaves the value intact. + /// + /// - Parameter expected: The expected current value. + /// - Parameter desired: The desired new value. + /// - Parameter successOrdering: The memory ordering to apply if this + /// operation performs the exchange. + /// - Parameter failureOrdering: The memory ordering to apply on this + /// operation does not perform the exchange. + /// - Returns: A tuple `(exchanged, original)`, where `exchanged` is true if + /// the exchange was successful, and `original` is the original value. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func weakCompareExchange( + expected: Value, + desired: __owned Value, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + Value.AtomicRepresentation.atomicWeakCompareExchange( + expected: expected, + desired: desired, + at: _ptr, + successOrdering: successOrdering, + failureOrdering: failureOrdering) + } +} + +extension ManagedAtomic where Value: AtomicInteger { + /// Perform an atomic wrapping add operation and return the original value, applying + /// the specified memory ordering. + /// + /// Note: This operation silently wraps around on overflow, like the + /// `&+` operator does on `Int` values. + /// + /// - Parameter operand: An integer 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 loadThenWrappingIncrement( + by operand: Value = 1, + ordering: AtomicUpdateOrdering + ) -> Value { + Value.AtomicRepresentation.atomicLoadThenWrappingIncrement( + by: operand, + at: _ptr, + ordering: ordering) + } + /// Perform an atomic wrapping subtract operation and return the original value, applying + /// the specified memory ordering. + /// + /// Note: This operation silently wraps around on overflow, like the + /// `&-` operator does on `Int` values. + /// + /// - Parameter operand: An integer 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 loadThenWrappingDecrement( + by operand: Value = 1, + ordering: AtomicUpdateOrdering + ) -> Value { + Value.AtomicRepresentation.atomicLoadThenWrappingDecrement( + by: operand, + at: _ptr, + ordering: ordering) + } + /// Perform an atomic bitwise AND operation and return the original value, applying + /// the specified memory ordering. + /// + /// - Parameter operand: An integer 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 loadThenBitwiseAnd( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + Value.AtomicRepresentation.atomicLoadThenBitwiseAnd( + with: operand, + at: _ptr, + ordering: ordering) + } + /// Perform an atomic bitwise OR operation and return the original value, applying + /// the specified memory ordering. + /// + /// - Parameter operand: An integer 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 loadThenBitwiseOr( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + Value.AtomicRepresentation.atomicLoadThenBitwiseOr( + with: operand, + at: _ptr, + ordering: ordering) + } + /// Perform an atomic bitwise XOR operation and return the original value, applying + /// the specified memory ordering. + /// + /// - Parameter operand: An integer 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 loadThenBitwiseXor( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + Value.AtomicRepresentation.atomicLoadThenBitwiseXor( + with: operand, + at: _ptr, + ordering: ordering) + } + + /// Perform an atomic wrapping add operation and return the new value, applying + /// the specified memory ordering. + /// + /// Note: This operation silently wraps around on overflow, like the + /// `&+` operator does on `Int` values. + /// + /// - Parameter operand: An integer value. + /// - Parameter ordering: The memory ordering to apply on this operation. + /// - Returns: The new value after the operation. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func wrappingIncrementThenLoad( + by operand: Value = 1, + ordering: AtomicUpdateOrdering + ) -> Value { + let original = Value.AtomicRepresentation.atomicLoadThenWrappingIncrement( + by: operand, + at: _ptr, + ordering: ordering) + return original &+ operand + } + /// Perform an atomic wrapping subtract operation and return the new value, applying + /// the specified memory ordering. + /// + /// Note: This operation silently wraps around on overflow, like the + /// `&-` operator does on `Int` values. + /// + /// - Parameter operand: An integer value. + /// - Parameter ordering: The memory ordering to apply on this operation. + /// - Returns: The new value after the operation. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func wrappingDecrementThenLoad( + by operand: Value = 1, + ordering: AtomicUpdateOrdering + ) -> Value { + let original = Value.AtomicRepresentation.atomicLoadThenWrappingDecrement( + by: operand, + at: _ptr, + ordering: ordering) + return original &- operand + } + /// Perform an atomic bitwise AND operation and return the new value, applying + /// the specified memory ordering. + /// + /// - Parameter operand: An integer value. + /// - Parameter ordering: The memory ordering to apply on this operation. + /// - Returns: The new value after the operation. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func bitwiseAndThenLoad( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + let original = Value.AtomicRepresentation.atomicLoadThenBitwiseAnd( + with: operand, + at: _ptr, + ordering: ordering) + return original & operand + } + /// Perform an atomic bitwise OR operation and return the new value, applying + /// the specified memory ordering. + /// + /// - Parameter operand: An integer value. + /// - Parameter ordering: The memory ordering to apply on this operation. + /// - Returns: The new value after the operation. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func bitwiseOrThenLoad( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + let original = Value.AtomicRepresentation.atomicLoadThenBitwiseOr( + with: operand, + at: _ptr, + ordering: ordering) + return original | operand + } + /// Perform an atomic bitwise XOR operation and return the new value, applying + /// the specified memory ordering. + /// + /// - Parameter operand: An integer value. + /// - Parameter ordering: The memory ordering to apply on this operation. + /// - Returns: The new value after the operation. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func bitwiseXorThenLoad( + with operand: Value, + ordering: AtomicUpdateOrdering + ) -> Value { + let original = Value.AtomicRepresentation.atomicLoadThenBitwiseXor( + with: operand, + at: _ptr, + ordering: ordering) + return original ^ operand + } + + /// Perform an atomic wrapping increment operation applying the + /// specified memory ordering. + /// + /// Note: This operation silently wraps around on overflow, like the + /// `&+=` operator does on `Int` values. + /// + /// - Parameter operand: The value to add to the current value. + /// - Parameter ordering: The memory ordering to apply on this operation. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func wrappingIncrement( + by operand: Value = 1, + ordering: AtomicUpdateOrdering + ) { + _ = Value.AtomicRepresentation.atomicLoadThenWrappingIncrement( + by: operand, + at: _ptr, + ordering: ordering) + } + + /// Perform an atomic wrapping decrement operation applying the + /// specified memory ordering. + /// + /// Note: This operation silently wraps around on overflow, like the + /// `&-=` operator does on `Int` values. + /// + /// - Parameter operand: The value to subtract from the current value. + /// - Parameter ordering: The memory ordering to apply on this operation. + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public func wrappingDecrement( + by operand: Value = 1, + ordering: AtomicUpdateOrdering + ) { + _ = Value.AtomicRepresentation.atomicLoadThenWrappingDecrement( + by: operand, + at: _ptr, + ordering: ordering) + } +} diff --git a/Sources/Atomics/autogenerated/IntegerConformances.swift b/Sources/Atomics/autogenerated/IntegerConformances.swift new file mode 100644 index 0000000..d7bd0a4 --- /dev/null +++ b/Sources/Atomics/autogenerated/IntegerConformances.swift @@ -0,0 +1,5264 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// + +// ############################################################################# +// # # +// # DO NOT EDIT THIS FILE; IT IS AUTOGENERATED. # +// # # +// ############################################################################# + + +import _AtomicsShims + +extension Int: AtomicValue { + public struct AtomicRepresentation { + public typealias Value = Int + + @usableFromInline + var _storage: _AtomicIntStorage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = _sa_prepare_Int(value) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + _sa_dispose_Int(_storage) + } + } +} + +extension UnsafeMutablePointer +where Pointee == Int.AtomicRepresentation { + @inlinable @inline(__always) + internal var _extract: UnsafeMutablePointer<_AtomicIntStorage> { + // `Int` is layout-compatible with its only stored property. + return UnsafeMutableRawPointer(self) + .assumingMemoryBound(to: _AtomicIntStorage.self) + } +} + +extension Int.AtomicRepresentation: AtomicStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_load_relaxed_Int(pointer._extract) + case .acquiring: + return _sa_load_acquire_Int(pointer._extract) + case .sequentiallyConsistent: + return _sa_load_seq_cst_Int(pointer._extract) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + switch ordering { + case .relaxed: + _sa_store_relaxed_Int(pointer._extract, desired) + case .releasing: + _sa_store_release_Int(pointer._extract, desired) + case .sequentiallyConsistent: + _sa_store_seq_cst_Int(pointer._extract, desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_exchange_relaxed_Int(pointer._extract, desired) + case .acquiring: + return _sa_exchange_acquire_Int(pointer._extract, desired) + case .releasing: + return _sa_exchange_release_Int(pointer._extract, desired) + case .acquiringAndReleasing: + return _sa_exchange_acq_rel_Int(pointer._extract, desired) + case .sequentiallyConsistent: + return _sa_exchange_seq_cst_Int(pointer._extract, desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + var expected = expected + let exchanged: Bool + switch ordering { + case .relaxed: + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_Int( + pointer._extract, + &expected, desired) + case .acquiring: + exchanged = _sa_cmpxchg_strong_acquire_acquire_Int( + pointer._extract, + &expected, desired) + case .releasing: + exchanged = _sa_cmpxchg_strong_release_relaxed_Int( + pointer._extract, + &expected, desired) + case .acquiringAndReleasing: + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_Int( + pointer._extract, + &expected, desired) + case .sequentiallyConsistent: + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int( + pointer._extract, + &expected, desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_Int( + pointer._extract, + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_Int( + pointer._extract, + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int( + pointer._extract, + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_strong_acquire_relaxed_Int( + pointer._extract, + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_Int( + pointer._extract, + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int( + pointer._extract, + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_strong_release_relaxed_Int( + pointer._extract, + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_Int( + pointer._extract, + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_strong_acq_rel_relaxed_Int( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_Int( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_strong_seq_cst_relaxed_Int( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_strong_seq_cst_acquire_Int( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int( + pointer._extract, + &expected, + desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicWeakCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_weak_relaxed_relaxed_Int( + pointer._extract, + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_Int( + pointer._extract, + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int( + pointer._extract, + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_weak_acquire_relaxed_Int( + pointer._extract, + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_Int( + pointer._extract, + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int( + pointer._extract, + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_weak_release_relaxed_Int( + pointer._extract, + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_Int( + pointer._extract, + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_weak_acq_rel_relaxed_Int( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_Int( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_weak_seq_cst_relaxed_Int( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_weak_seq_cst_acquire_Int( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int( + pointer._extract, + &expected, + desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } +} + +extension Int: AtomicInteger {} + +extension Int.AtomicRepresentation: AtomicIntegerStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenWrappingIncrement( + by operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_add_relaxed_Int( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_add_acquire_Int( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_add_release_Int( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_add_acq_rel_Int( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_add_seq_cst_Int( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenWrappingDecrement( + by operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_sub_relaxed_Int( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_sub_acquire_Int( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_sub_release_Int( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_sub_acq_rel_Int( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_sub_seq_cst_Int( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseAnd( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_and_relaxed_Int( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_and_acquire_Int( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_and_release_Int( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_and_acq_rel_Int( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_and_seq_cst_Int( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseOr( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_or_relaxed_Int( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_or_acquire_Int( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_or_release_Int( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_or_acq_rel_Int( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_or_seq_cst_Int( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseXor( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_xor_relaxed_Int( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_xor_acquire_Int( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_xor_release_Int( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_xor_acq_rel_Int( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_xor_seq_cst_Int( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } +} + +extension Int64: AtomicValue { + public struct AtomicRepresentation { + public typealias Value = Int64 + + @usableFromInline + var _storage: _AtomicInt64Storage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = _sa_prepare_Int64(value) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + _sa_dispose_Int64(_storage) + } + } +} + +extension UnsafeMutablePointer +where Pointee == Int64.AtomicRepresentation { + @inlinable @inline(__always) + internal var _extract: UnsafeMutablePointer<_AtomicInt64Storage> { + // `Int64` is layout-compatible with its only stored property. + return UnsafeMutableRawPointer(self) + .assumingMemoryBound(to: _AtomicInt64Storage.self) + } +} + +extension Int64.AtomicRepresentation: AtomicStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_load_relaxed_Int64(pointer._extract) + case .acquiring: + return _sa_load_acquire_Int64(pointer._extract) + case .sequentiallyConsistent: + return _sa_load_seq_cst_Int64(pointer._extract) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + switch ordering { + case .relaxed: + _sa_store_relaxed_Int64(pointer._extract, desired) + case .releasing: + _sa_store_release_Int64(pointer._extract, desired) + case .sequentiallyConsistent: + _sa_store_seq_cst_Int64(pointer._extract, desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_exchange_relaxed_Int64(pointer._extract, desired) + case .acquiring: + return _sa_exchange_acquire_Int64(pointer._extract, desired) + case .releasing: + return _sa_exchange_release_Int64(pointer._extract, desired) + case .acquiringAndReleasing: + return _sa_exchange_acq_rel_Int64(pointer._extract, desired) + case .sequentiallyConsistent: + return _sa_exchange_seq_cst_Int64(pointer._extract, desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + var expected = expected + let exchanged: Bool + switch ordering { + case .relaxed: + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_Int64( + pointer._extract, + &expected, desired) + case .acquiring: + exchanged = _sa_cmpxchg_strong_acquire_acquire_Int64( + pointer._extract, + &expected, desired) + case .releasing: + exchanged = _sa_cmpxchg_strong_release_relaxed_Int64( + pointer._extract, + &expected, desired) + case .acquiringAndReleasing: + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_Int64( + pointer._extract, + &expected, desired) + case .sequentiallyConsistent: + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int64( + pointer._extract, + &expected, desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_Int64( + pointer._extract, + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_Int64( + pointer._extract, + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int64( + pointer._extract, + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_strong_acquire_relaxed_Int64( + pointer._extract, + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_Int64( + pointer._extract, + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int64( + pointer._extract, + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_strong_release_relaxed_Int64( + pointer._extract, + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_Int64( + pointer._extract, + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int64( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_strong_acq_rel_relaxed_Int64( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_Int64( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int64( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_strong_seq_cst_relaxed_Int64( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_strong_seq_cst_acquire_Int64( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int64( + pointer._extract, + &expected, + desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicWeakCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_weak_relaxed_relaxed_Int64( + pointer._extract, + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_Int64( + pointer._extract, + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int64( + pointer._extract, + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_weak_acquire_relaxed_Int64( + pointer._extract, + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_Int64( + pointer._extract, + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int64( + pointer._extract, + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_weak_release_relaxed_Int64( + pointer._extract, + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_Int64( + pointer._extract, + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int64( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_weak_acq_rel_relaxed_Int64( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_Int64( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int64( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_weak_seq_cst_relaxed_Int64( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_weak_seq_cst_acquire_Int64( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int64( + pointer._extract, + &expected, + desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } +} + +extension Int64: AtomicInteger {} + +extension Int64.AtomicRepresentation: AtomicIntegerStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenWrappingIncrement( + by operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_add_relaxed_Int64( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_add_acquire_Int64( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_add_release_Int64( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_add_acq_rel_Int64( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_add_seq_cst_Int64( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenWrappingDecrement( + by operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_sub_relaxed_Int64( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_sub_acquire_Int64( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_sub_release_Int64( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_sub_acq_rel_Int64( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_sub_seq_cst_Int64( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseAnd( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_and_relaxed_Int64( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_and_acquire_Int64( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_and_release_Int64( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_and_acq_rel_Int64( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_and_seq_cst_Int64( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseOr( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_or_relaxed_Int64( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_or_acquire_Int64( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_or_release_Int64( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_or_acq_rel_Int64( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_or_seq_cst_Int64( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseXor( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_xor_relaxed_Int64( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_xor_acquire_Int64( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_xor_release_Int64( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_xor_acq_rel_Int64( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_xor_seq_cst_Int64( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } +} + +extension Int32: AtomicValue { + public struct AtomicRepresentation { + public typealias Value = Int32 + + @usableFromInline + var _storage: _AtomicInt32Storage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = _sa_prepare_Int32(value) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + _sa_dispose_Int32(_storage) + } + } +} + +extension UnsafeMutablePointer +where Pointee == Int32.AtomicRepresentation { + @inlinable @inline(__always) + internal var _extract: UnsafeMutablePointer<_AtomicInt32Storage> { + // `Int32` is layout-compatible with its only stored property. + return UnsafeMutableRawPointer(self) + .assumingMemoryBound(to: _AtomicInt32Storage.self) + } +} + +extension Int32.AtomicRepresentation: AtomicStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_load_relaxed_Int32(pointer._extract) + case .acquiring: + return _sa_load_acquire_Int32(pointer._extract) + case .sequentiallyConsistent: + return _sa_load_seq_cst_Int32(pointer._extract) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + switch ordering { + case .relaxed: + _sa_store_relaxed_Int32(pointer._extract, desired) + case .releasing: + _sa_store_release_Int32(pointer._extract, desired) + case .sequentiallyConsistent: + _sa_store_seq_cst_Int32(pointer._extract, desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_exchange_relaxed_Int32(pointer._extract, desired) + case .acquiring: + return _sa_exchange_acquire_Int32(pointer._extract, desired) + case .releasing: + return _sa_exchange_release_Int32(pointer._extract, desired) + case .acquiringAndReleasing: + return _sa_exchange_acq_rel_Int32(pointer._extract, desired) + case .sequentiallyConsistent: + return _sa_exchange_seq_cst_Int32(pointer._extract, desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + var expected = expected + let exchanged: Bool + switch ordering { + case .relaxed: + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_Int32( + pointer._extract, + &expected, desired) + case .acquiring: + exchanged = _sa_cmpxchg_strong_acquire_acquire_Int32( + pointer._extract, + &expected, desired) + case .releasing: + exchanged = _sa_cmpxchg_strong_release_relaxed_Int32( + pointer._extract, + &expected, desired) + case .acquiringAndReleasing: + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_Int32( + pointer._extract, + &expected, desired) + case .sequentiallyConsistent: + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int32( + pointer._extract, + &expected, desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_Int32( + pointer._extract, + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_Int32( + pointer._extract, + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int32( + pointer._extract, + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_strong_acquire_relaxed_Int32( + pointer._extract, + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_Int32( + pointer._extract, + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int32( + pointer._extract, + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_strong_release_relaxed_Int32( + pointer._extract, + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_Int32( + pointer._extract, + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int32( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_strong_acq_rel_relaxed_Int32( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_Int32( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int32( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_strong_seq_cst_relaxed_Int32( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_strong_seq_cst_acquire_Int32( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int32( + pointer._extract, + &expected, + desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicWeakCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_weak_relaxed_relaxed_Int32( + pointer._extract, + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_Int32( + pointer._extract, + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int32( + pointer._extract, + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_weak_acquire_relaxed_Int32( + pointer._extract, + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_Int32( + pointer._extract, + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int32( + pointer._extract, + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_weak_release_relaxed_Int32( + pointer._extract, + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_Int32( + pointer._extract, + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int32( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_weak_acq_rel_relaxed_Int32( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_Int32( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int32( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_weak_seq_cst_relaxed_Int32( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_weak_seq_cst_acquire_Int32( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int32( + pointer._extract, + &expected, + desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } +} + +extension Int32: AtomicInteger {} + +extension Int32.AtomicRepresentation: AtomicIntegerStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenWrappingIncrement( + by operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_add_relaxed_Int32( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_add_acquire_Int32( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_add_release_Int32( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_add_acq_rel_Int32( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_add_seq_cst_Int32( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenWrappingDecrement( + by operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_sub_relaxed_Int32( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_sub_acquire_Int32( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_sub_release_Int32( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_sub_acq_rel_Int32( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_sub_seq_cst_Int32( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseAnd( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_and_relaxed_Int32( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_and_acquire_Int32( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_and_release_Int32( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_and_acq_rel_Int32( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_and_seq_cst_Int32( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseOr( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_or_relaxed_Int32( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_or_acquire_Int32( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_or_release_Int32( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_or_acq_rel_Int32( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_or_seq_cst_Int32( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseXor( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_xor_relaxed_Int32( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_xor_acquire_Int32( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_xor_release_Int32( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_xor_acq_rel_Int32( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_xor_seq_cst_Int32( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } +} + +extension Int16: AtomicValue { + public struct AtomicRepresentation { + public typealias Value = Int16 + + @usableFromInline + var _storage: _AtomicInt16Storage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = _sa_prepare_Int16(value) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + _sa_dispose_Int16(_storage) + } + } +} + +extension UnsafeMutablePointer +where Pointee == Int16.AtomicRepresentation { + @inlinable @inline(__always) + internal var _extract: UnsafeMutablePointer<_AtomicInt16Storage> { + // `Int16` is layout-compatible with its only stored property. + return UnsafeMutableRawPointer(self) + .assumingMemoryBound(to: _AtomicInt16Storage.self) + } +} + +extension Int16.AtomicRepresentation: AtomicStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_load_relaxed_Int16(pointer._extract) + case .acquiring: + return _sa_load_acquire_Int16(pointer._extract) + case .sequentiallyConsistent: + return _sa_load_seq_cst_Int16(pointer._extract) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + switch ordering { + case .relaxed: + _sa_store_relaxed_Int16(pointer._extract, desired) + case .releasing: + _sa_store_release_Int16(pointer._extract, desired) + case .sequentiallyConsistent: + _sa_store_seq_cst_Int16(pointer._extract, desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_exchange_relaxed_Int16(pointer._extract, desired) + case .acquiring: + return _sa_exchange_acquire_Int16(pointer._extract, desired) + case .releasing: + return _sa_exchange_release_Int16(pointer._extract, desired) + case .acquiringAndReleasing: + return _sa_exchange_acq_rel_Int16(pointer._extract, desired) + case .sequentiallyConsistent: + return _sa_exchange_seq_cst_Int16(pointer._extract, desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + var expected = expected + let exchanged: Bool + switch ordering { + case .relaxed: + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_Int16( + pointer._extract, + &expected, desired) + case .acquiring: + exchanged = _sa_cmpxchg_strong_acquire_acquire_Int16( + pointer._extract, + &expected, desired) + case .releasing: + exchanged = _sa_cmpxchg_strong_release_relaxed_Int16( + pointer._extract, + &expected, desired) + case .acquiringAndReleasing: + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_Int16( + pointer._extract, + &expected, desired) + case .sequentiallyConsistent: + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int16( + pointer._extract, + &expected, desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_Int16( + pointer._extract, + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_Int16( + pointer._extract, + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int16( + pointer._extract, + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_strong_acquire_relaxed_Int16( + pointer._extract, + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_Int16( + pointer._extract, + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int16( + pointer._extract, + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_strong_release_relaxed_Int16( + pointer._extract, + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_Int16( + pointer._extract, + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int16( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_strong_acq_rel_relaxed_Int16( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_Int16( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int16( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_strong_seq_cst_relaxed_Int16( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_strong_seq_cst_acquire_Int16( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int16( + pointer._extract, + &expected, + desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicWeakCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_weak_relaxed_relaxed_Int16( + pointer._extract, + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_Int16( + pointer._extract, + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int16( + pointer._extract, + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_weak_acquire_relaxed_Int16( + pointer._extract, + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_Int16( + pointer._extract, + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int16( + pointer._extract, + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_weak_release_relaxed_Int16( + pointer._extract, + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_Int16( + pointer._extract, + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int16( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_weak_acq_rel_relaxed_Int16( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_Int16( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int16( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_weak_seq_cst_relaxed_Int16( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_weak_seq_cst_acquire_Int16( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int16( + pointer._extract, + &expected, + desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } +} + +extension Int16: AtomicInteger {} + +extension Int16.AtomicRepresentation: AtomicIntegerStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenWrappingIncrement( + by operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_add_relaxed_Int16( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_add_acquire_Int16( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_add_release_Int16( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_add_acq_rel_Int16( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_add_seq_cst_Int16( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenWrappingDecrement( + by operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_sub_relaxed_Int16( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_sub_acquire_Int16( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_sub_release_Int16( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_sub_acq_rel_Int16( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_sub_seq_cst_Int16( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseAnd( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_and_relaxed_Int16( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_and_acquire_Int16( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_and_release_Int16( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_and_acq_rel_Int16( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_and_seq_cst_Int16( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseOr( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_or_relaxed_Int16( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_or_acquire_Int16( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_or_release_Int16( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_or_acq_rel_Int16( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_or_seq_cst_Int16( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseXor( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_xor_relaxed_Int16( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_xor_acquire_Int16( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_xor_release_Int16( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_xor_acq_rel_Int16( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_xor_seq_cst_Int16( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } +} + +extension Int8: AtomicValue { + public struct AtomicRepresentation { + public typealias Value = Int8 + + @usableFromInline + var _storage: _AtomicInt8Storage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = _sa_prepare_Int8(value) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + _sa_dispose_Int8(_storage) + } + } +} + +extension UnsafeMutablePointer +where Pointee == Int8.AtomicRepresentation { + @inlinable @inline(__always) + internal var _extract: UnsafeMutablePointer<_AtomicInt8Storage> { + // `Int8` is layout-compatible with its only stored property. + return UnsafeMutableRawPointer(self) + .assumingMemoryBound(to: _AtomicInt8Storage.self) + } +} + +extension Int8.AtomicRepresentation: AtomicStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_load_relaxed_Int8(pointer._extract) + case .acquiring: + return _sa_load_acquire_Int8(pointer._extract) + case .sequentiallyConsistent: + return _sa_load_seq_cst_Int8(pointer._extract) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + switch ordering { + case .relaxed: + _sa_store_relaxed_Int8(pointer._extract, desired) + case .releasing: + _sa_store_release_Int8(pointer._extract, desired) + case .sequentiallyConsistent: + _sa_store_seq_cst_Int8(pointer._extract, desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_exchange_relaxed_Int8(pointer._extract, desired) + case .acquiring: + return _sa_exchange_acquire_Int8(pointer._extract, desired) + case .releasing: + return _sa_exchange_release_Int8(pointer._extract, desired) + case .acquiringAndReleasing: + return _sa_exchange_acq_rel_Int8(pointer._extract, desired) + case .sequentiallyConsistent: + return _sa_exchange_seq_cst_Int8(pointer._extract, desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + var expected = expected + let exchanged: Bool + switch ordering { + case .relaxed: + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_Int8( + pointer._extract, + &expected, desired) + case .acquiring: + exchanged = _sa_cmpxchg_strong_acquire_acquire_Int8( + pointer._extract, + &expected, desired) + case .releasing: + exchanged = _sa_cmpxchg_strong_release_relaxed_Int8( + pointer._extract, + &expected, desired) + case .acquiringAndReleasing: + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_Int8( + pointer._extract, + &expected, desired) + case .sequentiallyConsistent: + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int8( + pointer._extract, + &expected, desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_Int8( + pointer._extract, + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_Int8( + pointer._extract, + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int8( + pointer._extract, + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_strong_acquire_relaxed_Int8( + pointer._extract, + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_Int8( + pointer._extract, + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int8( + pointer._extract, + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_strong_release_relaxed_Int8( + pointer._extract, + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_Int8( + pointer._extract, + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int8( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_strong_acq_rel_relaxed_Int8( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_Int8( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int8( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_strong_seq_cst_relaxed_Int8( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_strong_seq_cst_acquire_Int8( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_Int8( + pointer._extract, + &expected, + desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicWeakCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_weak_relaxed_relaxed_Int8( + pointer._extract, + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_Int8( + pointer._extract, + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int8( + pointer._extract, + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_weak_acquire_relaxed_Int8( + pointer._extract, + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_Int8( + pointer._extract, + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int8( + pointer._extract, + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_weak_release_relaxed_Int8( + pointer._extract, + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_Int8( + pointer._extract, + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int8( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_weak_acq_rel_relaxed_Int8( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_Int8( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int8( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_weak_seq_cst_relaxed_Int8( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_weak_seq_cst_acquire_Int8( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_Int8( + pointer._extract, + &expected, + desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } +} + +extension Int8: AtomicInteger {} + +extension Int8.AtomicRepresentation: AtomicIntegerStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenWrappingIncrement( + by operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_add_relaxed_Int8( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_add_acquire_Int8( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_add_release_Int8( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_add_acq_rel_Int8( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_add_seq_cst_Int8( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenWrappingDecrement( + by operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_sub_relaxed_Int8( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_sub_acquire_Int8( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_sub_release_Int8( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_sub_acq_rel_Int8( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_sub_seq_cst_Int8( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseAnd( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_and_relaxed_Int8( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_and_acquire_Int8( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_and_release_Int8( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_and_acq_rel_Int8( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_and_seq_cst_Int8( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseOr( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_or_relaxed_Int8( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_or_acquire_Int8( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_or_release_Int8( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_or_acq_rel_Int8( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_or_seq_cst_Int8( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseXor( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_xor_relaxed_Int8( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_xor_acquire_Int8( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_xor_release_Int8( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_xor_acq_rel_Int8( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_xor_seq_cst_Int8( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } +} + +extension UInt: AtomicValue { + public struct AtomicRepresentation { + public typealias Value = UInt + + @usableFromInline + var _storage: _AtomicUIntStorage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = _sa_prepare_UInt(value) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + _sa_dispose_UInt(_storage) + } + } +} + +extension UnsafeMutablePointer +where Pointee == UInt.AtomicRepresentation { + @inlinable @inline(__always) + internal var _extract: UnsafeMutablePointer<_AtomicUIntStorage> { + // `UInt` is layout-compatible with its only stored property. + return UnsafeMutableRawPointer(self) + .assumingMemoryBound(to: _AtomicUIntStorage.self) + } +} + +extension UInt.AtomicRepresentation: AtomicStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_load_relaxed_UInt(pointer._extract) + case .acquiring: + return _sa_load_acquire_UInt(pointer._extract) + case .sequentiallyConsistent: + return _sa_load_seq_cst_UInt(pointer._extract) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + switch ordering { + case .relaxed: + _sa_store_relaxed_UInt(pointer._extract, desired) + case .releasing: + _sa_store_release_UInt(pointer._extract, desired) + case .sequentiallyConsistent: + _sa_store_seq_cst_UInt(pointer._extract, desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_exchange_relaxed_UInt(pointer._extract, desired) + case .acquiring: + return _sa_exchange_acquire_UInt(pointer._extract, desired) + case .releasing: + return _sa_exchange_release_UInt(pointer._extract, desired) + case .acquiringAndReleasing: + return _sa_exchange_acq_rel_UInt(pointer._extract, desired) + case .sequentiallyConsistent: + return _sa_exchange_seq_cst_UInt(pointer._extract, desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + var expected = expected + let exchanged: Bool + switch ordering { + case .relaxed: + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_UInt( + pointer._extract, + &expected, desired) + case .acquiring: + exchanged = _sa_cmpxchg_strong_acquire_acquire_UInt( + pointer._extract, + &expected, desired) + case .releasing: + exchanged = _sa_cmpxchg_strong_release_relaxed_UInt( + pointer._extract, + &expected, desired) + case .acquiringAndReleasing: + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_UInt( + pointer._extract, + &expected, desired) + case .sequentiallyConsistent: + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt( + pointer._extract, + &expected, desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_UInt( + pointer._extract, + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_UInt( + pointer._extract, + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt( + pointer._extract, + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_strong_acquire_relaxed_UInt( + pointer._extract, + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_UInt( + pointer._extract, + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt( + pointer._extract, + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_strong_release_relaxed_UInt( + pointer._extract, + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_UInt( + pointer._extract, + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_strong_acq_rel_relaxed_UInt( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_UInt( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_strong_seq_cst_relaxed_UInt( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_strong_seq_cst_acquire_UInt( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt( + pointer._extract, + &expected, + desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicWeakCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_weak_relaxed_relaxed_UInt( + pointer._extract, + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_UInt( + pointer._extract, + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt( + pointer._extract, + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_weak_acquire_relaxed_UInt( + pointer._extract, + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_UInt( + pointer._extract, + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt( + pointer._extract, + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_weak_release_relaxed_UInt( + pointer._extract, + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_UInt( + pointer._extract, + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_weak_acq_rel_relaxed_UInt( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_UInt( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_weak_seq_cst_relaxed_UInt( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_weak_seq_cst_acquire_UInt( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt( + pointer._extract, + &expected, + desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } +} + +extension UInt: AtomicInteger {} + +extension UInt.AtomicRepresentation: AtomicIntegerStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenWrappingIncrement( + by operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_add_relaxed_UInt( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_add_acquire_UInt( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_add_release_UInt( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_add_acq_rel_UInt( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_add_seq_cst_UInt( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenWrappingDecrement( + by operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_sub_relaxed_UInt( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_sub_acquire_UInt( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_sub_release_UInt( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_sub_acq_rel_UInt( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_sub_seq_cst_UInt( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseAnd( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_and_relaxed_UInt( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_and_acquire_UInt( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_and_release_UInt( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_and_acq_rel_UInt( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_and_seq_cst_UInt( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseOr( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_or_relaxed_UInt( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_or_acquire_UInt( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_or_release_UInt( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_or_acq_rel_UInt( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_or_seq_cst_UInt( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseXor( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_xor_relaxed_UInt( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_xor_acquire_UInt( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_xor_release_UInt( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_xor_acq_rel_UInt( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_xor_seq_cst_UInt( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } +} + +extension UInt64: AtomicValue { + public struct AtomicRepresentation { + public typealias Value = UInt64 + + @usableFromInline + var _storage: _AtomicUInt64Storage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = _sa_prepare_UInt64(value) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + _sa_dispose_UInt64(_storage) + } + } +} + +extension UnsafeMutablePointer +where Pointee == UInt64.AtomicRepresentation { + @inlinable @inline(__always) + internal var _extract: UnsafeMutablePointer<_AtomicUInt64Storage> { + // `UInt64` is layout-compatible with its only stored property. + return UnsafeMutableRawPointer(self) + .assumingMemoryBound(to: _AtomicUInt64Storage.self) + } +} + +extension UInt64.AtomicRepresentation: AtomicStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_load_relaxed_UInt64(pointer._extract) + case .acquiring: + return _sa_load_acquire_UInt64(pointer._extract) + case .sequentiallyConsistent: + return _sa_load_seq_cst_UInt64(pointer._extract) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + switch ordering { + case .relaxed: + _sa_store_relaxed_UInt64(pointer._extract, desired) + case .releasing: + _sa_store_release_UInt64(pointer._extract, desired) + case .sequentiallyConsistent: + _sa_store_seq_cst_UInt64(pointer._extract, desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_exchange_relaxed_UInt64(pointer._extract, desired) + case .acquiring: + return _sa_exchange_acquire_UInt64(pointer._extract, desired) + case .releasing: + return _sa_exchange_release_UInt64(pointer._extract, desired) + case .acquiringAndReleasing: + return _sa_exchange_acq_rel_UInt64(pointer._extract, desired) + case .sequentiallyConsistent: + return _sa_exchange_seq_cst_UInt64(pointer._extract, desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + var expected = expected + let exchanged: Bool + switch ordering { + case .relaxed: + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_UInt64( + pointer._extract, + &expected, desired) + case .acquiring: + exchanged = _sa_cmpxchg_strong_acquire_acquire_UInt64( + pointer._extract, + &expected, desired) + case .releasing: + exchanged = _sa_cmpxchg_strong_release_relaxed_UInt64( + pointer._extract, + &expected, desired) + case .acquiringAndReleasing: + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_UInt64( + pointer._extract, + &expected, desired) + case .sequentiallyConsistent: + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt64( + pointer._extract, + &expected, desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_UInt64( + pointer._extract, + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_UInt64( + pointer._extract, + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt64( + pointer._extract, + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_strong_acquire_relaxed_UInt64( + pointer._extract, + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_UInt64( + pointer._extract, + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt64( + pointer._extract, + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_strong_release_relaxed_UInt64( + pointer._extract, + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_UInt64( + pointer._extract, + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt64( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_strong_acq_rel_relaxed_UInt64( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_UInt64( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt64( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_strong_seq_cst_relaxed_UInt64( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_strong_seq_cst_acquire_UInt64( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt64( + pointer._extract, + &expected, + desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicWeakCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_weak_relaxed_relaxed_UInt64( + pointer._extract, + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_UInt64( + pointer._extract, + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt64( + pointer._extract, + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_weak_acquire_relaxed_UInt64( + pointer._extract, + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_UInt64( + pointer._extract, + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt64( + pointer._extract, + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_weak_release_relaxed_UInt64( + pointer._extract, + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_UInt64( + pointer._extract, + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt64( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_weak_acq_rel_relaxed_UInt64( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_UInt64( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt64( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_weak_seq_cst_relaxed_UInt64( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_weak_seq_cst_acquire_UInt64( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt64( + pointer._extract, + &expected, + desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } +} + +extension UInt64: AtomicInteger {} + +extension UInt64.AtomicRepresentation: AtomicIntegerStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenWrappingIncrement( + by operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_add_relaxed_UInt64( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_add_acquire_UInt64( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_add_release_UInt64( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_add_acq_rel_UInt64( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_add_seq_cst_UInt64( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenWrappingDecrement( + by operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_sub_relaxed_UInt64( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_sub_acquire_UInt64( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_sub_release_UInt64( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_sub_acq_rel_UInt64( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_sub_seq_cst_UInt64( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseAnd( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_and_relaxed_UInt64( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_and_acquire_UInt64( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_and_release_UInt64( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_and_acq_rel_UInt64( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_and_seq_cst_UInt64( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseOr( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_or_relaxed_UInt64( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_or_acquire_UInt64( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_or_release_UInt64( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_or_acq_rel_UInt64( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_or_seq_cst_UInt64( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseXor( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_xor_relaxed_UInt64( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_xor_acquire_UInt64( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_xor_release_UInt64( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_xor_acq_rel_UInt64( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_xor_seq_cst_UInt64( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } +} + +extension UInt32: AtomicValue { + public struct AtomicRepresentation { + public typealias Value = UInt32 + + @usableFromInline + var _storage: _AtomicUInt32Storage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = _sa_prepare_UInt32(value) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + _sa_dispose_UInt32(_storage) + } + } +} + +extension UnsafeMutablePointer +where Pointee == UInt32.AtomicRepresentation { + @inlinable @inline(__always) + internal var _extract: UnsafeMutablePointer<_AtomicUInt32Storage> { + // `UInt32` is layout-compatible with its only stored property. + return UnsafeMutableRawPointer(self) + .assumingMemoryBound(to: _AtomicUInt32Storage.self) + } +} + +extension UInt32.AtomicRepresentation: AtomicStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_load_relaxed_UInt32(pointer._extract) + case .acquiring: + return _sa_load_acquire_UInt32(pointer._extract) + case .sequentiallyConsistent: + return _sa_load_seq_cst_UInt32(pointer._extract) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + switch ordering { + case .relaxed: + _sa_store_relaxed_UInt32(pointer._extract, desired) + case .releasing: + _sa_store_release_UInt32(pointer._extract, desired) + case .sequentiallyConsistent: + _sa_store_seq_cst_UInt32(pointer._extract, desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_exchange_relaxed_UInt32(pointer._extract, desired) + case .acquiring: + return _sa_exchange_acquire_UInt32(pointer._extract, desired) + case .releasing: + return _sa_exchange_release_UInt32(pointer._extract, desired) + case .acquiringAndReleasing: + return _sa_exchange_acq_rel_UInt32(pointer._extract, desired) + case .sequentiallyConsistent: + return _sa_exchange_seq_cst_UInt32(pointer._extract, desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + var expected = expected + let exchanged: Bool + switch ordering { + case .relaxed: + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_UInt32( + pointer._extract, + &expected, desired) + case .acquiring: + exchanged = _sa_cmpxchg_strong_acquire_acquire_UInt32( + pointer._extract, + &expected, desired) + case .releasing: + exchanged = _sa_cmpxchg_strong_release_relaxed_UInt32( + pointer._extract, + &expected, desired) + case .acquiringAndReleasing: + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_UInt32( + pointer._extract, + &expected, desired) + case .sequentiallyConsistent: + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt32( + pointer._extract, + &expected, desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_UInt32( + pointer._extract, + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_UInt32( + pointer._extract, + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt32( + pointer._extract, + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_strong_acquire_relaxed_UInt32( + pointer._extract, + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_UInt32( + pointer._extract, + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt32( + pointer._extract, + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_strong_release_relaxed_UInt32( + pointer._extract, + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_UInt32( + pointer._extract, + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt32( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_strong_acq_rel_relaxed_UInt32( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_UInt32( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt32( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_strong_seq_cst_relaxed_UInt32( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_strong_seq_cst_acquire_UInt32( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt32( + pointer._extract, + &expected, + desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicWeakCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_weak_relaxed_relaxed_UInt32( + pointer._extract, + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_UInt32( + pointer._extract, + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt32( + pointer._extract, + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_weak_acquire_relaxed_UInt32( + pointer._extract, + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_UInt32( + pointer._extract, + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt32( + pointer._extract, + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_weak_release_relaxed_UInt32( + pointer._extract, + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_UInt32( + pointer._extract, + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt32( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_weak_acq_rel_relaxed_UInt32( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_UInt32( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt32( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_weak_seq_cst_relaxed_UInt32( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_weak_seq_cst_acquire_UInt32( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt32( + pointer._extract, + &expected, + desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } +} + +extension UInt32: AtomicInteger {} + +extension UInt32.AtomicRepresentation: AtomicIntegerStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenWrappingIncrement( + by operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_add_relaxed_UInt32( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_add_acquire_UInt32( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_add_release_UInt32( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_add_acq_rel_UInt32( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_add_seq_cst_UInt32( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenWrappingDecrement( + by operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_sub_relaxed_UInt32( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_sub_acquire_UInt32( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_sub_release_UInt32( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_sub_acq_rel_UInt32( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_sub_seq_cst_UInt32( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseAnd( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_and_relaxed_UInt32( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_and_acquire_UInt32( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_and_release_UInt32( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_and_acq_rel_UInt32( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_and_seq_cst_UInt32( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseOr( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_or_relaxed_UInt32( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_or_acquire_UInt32( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_or_release_UInt32( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_or_acq_rel_UInt32( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_or_seq_cst_UInt32( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseXor( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_xor_relaxed_UInt32( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_xor_acquire_UInt32( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_xor_release_UInt32( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_xor_acq_rel_UInt32( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_xor_seq_cst_UInt32( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } +} + +extension UInt16: AtomicValue { + public struct AtomicRepresentation { + public typealias Value = UInt16 + + @usableFromInline + var _storage: _AtomicUInt16Storage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = _sa_prepare_UInt16(value) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + _sa_dispose_UInt16(_storage) + } + } +} + +extension UnsafeMutablePointer +where Pointee == UInt16.AtomicRepresentation { + @inlinable @inline(__always) + internal var _extract: UnsafeMutablePointer<_AtomicUInt16Storage> { + // `UInt16` is layout-compatible with its only stored property. + return UnsafeMutableRawPointer(self) + .assumingMemoryBound(to: _AtomicUInt16Storage.self) + } +} + +extension UInt16.AtomicRepresentation: AtomicStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_load_relaxed_UInt16(pointer._extract) + case .acquiring: + return _sa_load_acquire_UInt16(pointer._extract) + case .sequentiallyConsistent: + return _sa_load_seq_cst_UInt16(pointer._extract) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + switch ordering { + case .relaxed: + _sa_store_relaxed_UInt16(pointer._extract, desired) + case .releasing: + _sa_store_release_UInt16(pointer._extract, desired) + case .sequentiallyConsistent: + _sa_store_seq_cst_UInt16(pointer._extract, desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_exchange_relaxed_UInt16(pointer._extract, desired) + case .acquiring: + return _sa_exchange_acquire_UInt16(pointer._extract, desired) + case .releasing: + return _sa_exchange_release_UInt16(pointer._extract, desired) + case .acquiringAndReleasing: + return _sa_exchange_acq_rel_UInt16(pointer._extract, desired) + case .sequentiallyConsistent: + return _sa_exchange_seq_cst_UInt16(pointer._extract, desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + var expected = expected + let exchanged: Bool + switch ordering { + case .relaxed: + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_UInt16( + pointer._extract, + &expected, desired) + case .acquiring: + exchanged = _sa_cmpxchg_strong_acquire_acquire_UInt16( + pointer._extract, + &expected, desired) + case .releasing: + exchanged = _sa_cmpxchg_strong_release_relaxed_UInt16( + pointer._extract, + &expected, desired) + case .acquiringAndReleasing: + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_UInt16( + pointer._extract, + &expected, desired) + case .sequentiallyConsistent: + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt16( + pointer._extract, + &expected, desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_UInt16( + pointer._extract, + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_UInt16( + pointer._extract, + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt16( + pointer._extract, + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_strong_acquire_relaxed_UInt16( + pointer._extract, + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_UInt16( + pointer._extract, + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt16( + pointer._extract, + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_strong_release_relaxed_UInt16( + pointer._extract, + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_UInt16( + pointer._extract, + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt16( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_strong_acq_rel_relaxed_UInt16( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_UInt16( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt16( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_strong_seq_cst_relaxed_UInt16( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_strong_seq_cst_acquire_UInt16( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt16( + pointer._extract, + &expected, + desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicWeakCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_weak_relaxed_relaxed_UInt16( + pointer._extract, + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_UInt16( + pointer._extract, + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt16( + pointer._extract, + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_weak_acquire_relaxed_UInt16( + pointer._extract, + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_UInt16( + pointer._extract, + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt16( + pointer._extract, + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_weak_release_relaxed_UInt16( + pointer._extract, + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_UInt16( + pointer._extract, + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt16( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_weak_acq_rel_relaxed_UInt16( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_UInt16( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt16( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_weak_seq_cst_relaxed_UInt16( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_weak_seq_cst_acquire_UInt16( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt16( + pointer._extract, + &expected, + desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } +} + +extension UInt16: AtomicInteger {} + +extension UInt16.AtomicRepresentation: AtomicIntegerStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenWrappingIncrement( + by operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_add_relaxed_UInt16( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_add_acquire_UInt16( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_add_release_UInt16( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_add_acq_rel_UInt16( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_add_seq_cst_UInt16( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenWrappingDecrement( + by operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_sub_relaxed_UInt16( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_sub_acquire_UInt16( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_sub_release_UInt16( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_sub_acq_rel_UInt16( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_sub_seq_cst_UInt16( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseAnd( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_and_relaxed_UInt16( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_and_acquire_UInt16( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_and_release_UInt16( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_and_acq_rel_UInt16( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_and_seq_cst_UInt16( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseOr( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_or_relaxed_UInt16( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_or_acquire_UInt16( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_or_release_UInt16( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_or_acq_rel_UInt16( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_or_seq_cst_UInt16( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseXor( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_xor_relaxed_UInt16( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_xor_acquire_UInt16( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_xor_release_UInt16( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_xor_acq_rel_UInt16( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_xor_seq_cst_UInt16( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } +} + +extension UInt8: AtomicValue { + public struct AtomicRepresentation { + public typealias Value = UInt8 + + @usableFromInline + var _storage: _AtomicUInt8Storage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = _sa_prepare_UInt8(value) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + _sa_dispose_UInt8(_storage) + } + } +} + +extension UnsafeMutablePointer +where Pointee == UInt8.AtomicRepresentation { + @inlinable @inline(__always) + internal var _extract: UnsafeMutablePointer<_AtomicUInt8Storage> { + // `UInt8` is layout-compatible with its only stored property. + return UnsafeMutableRawPointer(self) + .assumingMemoryBound(to: _AtomicUInt8Storage.self) + } +} + +extension UInt8.AtomicRepresentation: AtomicStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_load_relaxed_UInt8(pointer._extract) + case .acquiring: + return _sa_load_acquire_UInt8(pointer._extract) + case .sequentiallyConsistent: + return _sa_load_seq_cst_UInt8(pointer._extract) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + switch ordering { + case .relaxed: + _sa_store_relaxed_UInt8(pointer._extract, desired) + case .releasing: + _sa_store_release_UInt8(pointer._extract, desired) + case .sequentiallyConsistent: + _sa_store_seq_cst_UInt8(pointer._extract, desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_exchange_relaxed_UInt8(pointer._extract, desired) + case .acquiring: + return _sa_exchange_acquire_UInt8(pointer._extract, desired) + case .releasing: + return _sa_exchange_release_UInt8(pointer._extract, desired) + case .acquiringAndReleasing: + return _sa_exchange_acq_rel_UInt8(pointer._extract, desired) + case .sequentiallyConsistent: + return _sa_exchange_seq_cst_UInt8(pointer._extract, desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + var expected = expected + let exchanged: Bool + switch ordering { + case .relaxed: + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_UInt8( + pointer._extract, + &expected, desired) + case .acquiring: + exchanged = _sa_cmpxchg_strong_acquire_acquire_UInt8( + pointer._extract, + &expected, desired) + case .releasing: + exchanged = _sa_cmpxchg_strong_release_relaxed_UInt8( + pointer._extract, + &expected, desired) + case .acquiringAndReleasing: + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_UInt8( + pointer._extract, + &expected, desired) + case .sequentiallyConsistent: + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt8( + pointer._extract, + &expected, desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_UInt8( + pointer._extract, + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_UInt8( + pointer._extract, + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt8( + pointer._extract, + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_strong_acquire_relaxed_UInt8( + pointer._extract, + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_UInt8( + pointer._extract, + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt8( + pointer._extract, + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_strong_release_relaxed_UInt8( + pointer._extract, + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_UInt8( + pointer._extract, + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt8( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_strong_acq_rel_relaxed_UInt8( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_UInt8( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt8( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_strong_seq_cst_relaxed_UInt8( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_strong_seq_cst_acquire_UInt8( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_UInt8( + pointer._extract, + &expected, + desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicWeakCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_weak_relaxed_relaxed_UInt8( + pointer._extract, + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_UInt8( + pointer._extract, + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt8( + pointer._extract, + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_weak_acquire_relaxed_UInt8( + pointer._extract, + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_UInt8( + pointer._extract, + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt8( + pointer._extract, + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_weak_release_relaxed_UInt8( + pointer._extract, + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_UInt8( + pointer._extract, + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt8( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_weak_acq_rel_relaxed_UInt8( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_UInt8( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt8( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_weak_seq_cst_relaxed_UInt8( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_weak_seq_cst_acquire_UInt8( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_UInt8( + pointer._extract, + &expected, + desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } +} + +extension UInt8: AtomicInteger {} + +extension UInt8.AtomicRepresentation: AtomicIntegerStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenWrappingIncrement( + by operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_add_relaxed_UInt8( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_add_acquire_UInt8( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_add_release_UInt8( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_add_acq_rel_UInt8( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_add_seq_cst_UInt8( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenWrappingDecrement( + by operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_sub_relaxed_UInt8( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_sub_acquire_UInt8( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_sub_release_UInt8( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_sub_acq_rel_UInt8( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_sub_seq_cst_UInt8( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseAnd( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_and_relaxed_UInt8( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_and_acquire_UInt8( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_and_release_UInt8( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_and_acq_rel_UInt8( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_and_seq_cst_UInt8( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseOr( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_or_relaxed_UInt8( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_or_acquire_UInt8( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_or_release_UInt8( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_or_acq_rel_UInt8( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_or_seq_cst_UInt8( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + @discardableResult + public static func atomicLoadThenBitwiseXor( + with operand: Value = 1, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_fetch_xor_relaxed_UInt8( + pointer._extract, + operand) + case .acquiring: + return _sa_fetch_xor_acquire_UInt8( + pointer._extract, + operand) + case .releasing: + return _sa_fetch_xor_release_UInt8( + pointer._extract, + operand) + case .acquiringAndReleasing: + return _sa_fetch_xor_acq_rel_UInt8( + pointer._extract, + operand) + case .sequentiallyConsistent: + return _sa_fetch_xor_seq_cst_UInt8( + pointer._extract, + operand) + default: + fatalError("Unsupported ordering") + } + } +} + +extension DoubleWord: AtomicValue { + public struct AtomicRepresentation { + public typealias Value = DoubleWord + + @usableFromInline + var _storage: _AtomicDoubleWordStorage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = _sa_prepare_DoubleWord(value) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + _sa_dispose_DoubleWord(_storage) + } + } +} + +extension UnsafeMutablePointer +where Pointee == DoubleWord.AtomicRepresentation { + @inlinable @inline(__always) + internal var _extract: UnsafeMutablePointer<_AtomicDoubleWordStorage> { + // `DoubleWord` is layout-compatible with its only stored property. + return UnsafeMutableRawPointer(self) + .assumingMemoryBound(to: _AtomicDoubleWordStorage.self) + } +} + +extension DoubleWord.AtomicRepresentation: AtomicStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_load_relaxed_DoubleWord(pointer._extract) + case .acquiring: + return _sa_load_acquire_DoubleWord(pointer._extract) + case .sequentiallyConsistent: + return _sa_load_seq_cst_DoubleWord(pointer._extract) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + switch ordering { + case .relaxed: + _sa_store_relaxed_DoubleWord(pointer._extract, desired) + case .releasing: + _sa_store_release_DoubleWord(pointer._extract, desired) + case .sequentiallyConsistent: + _sa_store_seq_cst_DoubleWord(pointer._extract, desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + switch ordering { + case .relaxed: + return _sa_exchange_relaxed_DoubleWord(pointer._extract, desired) + case .acquiring: + return _sa_exchange_acquire_DoubleWord(pointer._extract, desired) + case .releasing: + return _sa_exchange_release_DoubleWord(pointer._extract, desired) + case .acquiringAndReleasing: + return _sa_exchange_acq_rel_DoubleWord(pointer._extract, desired) + case .sequentiallyConsistent: + return _sa_exchange_seq_cst_DoubleWord(pointer._extract, desired) + default: + fatalError("Unsupported ordering") + } + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + var expected = expected + let exchanged: Bool + switch ordering { + case .relaxed: + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_DoubleWord( + pointer._extract, + &expected, desired) + case .acquiring: + exchanged = _sa_cmpxchg_strong_acquire_acquire_DoubleWord( + pointer._extract, + &expected, desired) + case .releasing: + exchanged = _sa_cmpxchg_strong_release_relaxed_DoubleWord( + pointer._extract, + &expected, desired) + case .acquiringAndReleasing: + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_DoubleWord( + pointer._extract, + &expected, desired) + case .sequentiallyConsistent: + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_DoubleWord( + pointer._extract, + &expected, desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_strong_relaxed_relaxed_DoubleWord( + pointer._extract, + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_DoubleWord( + pointer._extract, + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_DoubleWord( + pointer._extract, + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_strong_acquire_relaxed_DoubleWord( + pointer._extract, + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_strong_acquire_acquire_DoubleWord( + pointer._extract, + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_DoubleWord( + pointer._extract, + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_strong_release_relaxed_DoubleWord( + pointer._extract, + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_DoubleWord( + pointer._extract, + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_DoubleWord( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_strong_acq_rel_relaxed_DoubleWord( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_strong_acq_rel_acquire_DoubleWord( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_DoubleWord( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_strong_seq_cst_relaxed_DoubleWord( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_strong_seq_cst_acquire_DoubleWord( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_strong_seq_cst_seq_cst_DoubleWord( + pointer._extract, + &expected, + desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicWeakCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + 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) { + case (.relaxed, .relaxed): + exchanged = _sa_cmpxchg_weak_relaxed_relaxed_DoubleWord( + pointer._extract, + &expected, + desired) + case (.relaxed, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_DoubleWord( + pointer._extract, + &expected, + desired) + case (.relaxed, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_DoubleWord( + pointer._extract, + &expected, + desired) + case (.acquiring, .relaxed): + exchanged = _sa_cmpxchg_weak_acquire_relaxed_DoubleWord( + pointer._extract, + &expected, + desired) + case (.acquiring, .acquiring): + exchanged = _sa_cmpxchg_weak_acquire_acquire_DoubleWord( + pointer._extract, + &expected, + desired) + case (.acquiring, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_DoubleWord( + pointer._extract, + &expected, + desired) + case (.releasing, .relaxed): + exchanged = _sa_cmpxchg_weak_release_relaxed_DoubleWord( + pointer._extract, + &expected, + desired) + case (.releasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_DoubleWord( + pointer._extract, + &expected, + desired) + case (.releasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_DoubleWord( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .relaxed): + exchanged = _sa_cmpxchg_weak_acq_rel_relaxed_DoubleWord( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .acquiring): + exchanged = _sa_cmpxchg_weak_acq_rel_acquire_DoubleWord( + pointer._extract, + &expected, + desired) + case (.acquiringAndReleasing, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_DoubleWord( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .relaxed): + exchanged = _sa_cmpxchg_weak_seq_cst_relaxed_DoubleWord( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .acquiring): + exchanged = _sa_cmpxchg_weak_seq_cst_acquire_DoubleWord( + pointer._extract, + &expected, + desired) + case (.sequentiallyConsistent, .sequentiallyConsistent): + exchanged = _sa_cmpxchg_weak_seq_cst_seq_cst_DoubleWord( + pointer._extract, + &expected, + desired) + default: + fatalError("Unsupported ordering") + } + return (exchanged, expected) + } +} + + diff --git a/Sources/Atomics/autogenerated/PointerConformances.swift b/Sources/Atomics/autogenerated/PointerConformances.swift new file mode 100644 index 0000000..6cf5dfe --- /dev/null +++ b/Sources/Atomics/autogenerated/PointerConformances.swift @@ -0,0 +1,1290 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// + + +// ############################################################################# +// # # +// # DO NOT EDIT THIS FILE; IT IS AUTOGENERATED. # +// # # +// ############################################################################# + + +extension UnsafeRawPointer: AtomicValue { + @frozen + public struct AtomicRepresentation { + public typealias Value = UnsafeRawPointer + @usableFromInline internal typealias Storage = Int.AtomicRepresentation + + @usableFromInline + internal let _storage: Storage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = .init(Self._encode(value)) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + Self._decode(_storage.dispose()) + } + } +} + +extension UnsafeRawPointer.AtomicRepresentation { + @_transparent @_alwaysEmitIntoClient + @usableFromInline + internal static func _extract( + _ ptr: UnsafeMutablePointer + ) -> UnsafeMutablePointer { + // `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 { + return UnsafeRawPointer(bitPattern: bitPattern)! + } + + @_transparent @_alwaysEmitIntoClient + internal static func _encode(_ value: Value) -> Int { + return Int(bitPattern: value) + } +} + +extension UnsafeRawPointer.AtomicRepresentation: AtomicStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + let encoded = Storage.atomicLoad(at: _extract(pointer), ordering: ordering) + return _decode(encoded) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + Storage.atomicStore(_encode(desired), at: _extract(pointer), ordering: ordering) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + _decode(Storage.atomicExchange(_encode(desired), at: _extract(pointer), ordering: ordering)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + ordering: ordering) + return (exchanged, _decode(original)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + 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, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicWeakCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + successOrdering: successOrdering, + failureOrdering: failureOrdering) + return (exchanged, _decode(original)) + } +} +extension UnsafeMutableRawPointer: AtomicValue { + @frozen + public struct AtomicRepresentation { + public typealias Value = UnsafeMutableRawPointer + @usableFromInline internal typealias Storage = Int.AtomicRepresentation + + @usableFromInline + internal let _storage: Storage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = .init(Self._encode(value)) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + Self._decode(_storage.dispose()) + } + } +} + +extension UnsafeMutableRawPointer.AtomicRepresentation { + @_transparent @_alwaysEmitIntoClient + @usableFromInline + internal static func _extract( + _ ptr: UnsafeMutablePointer + ) -> UnsafeMutablePointer { + // `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 { + return UnsafeMutableRawPointer(bitPattern: bitPattern)! + } + + @_transparent @_alwaysEmitIntoClient + internal static func _encode(_ value: Value) -> Int { + return Int(bitPattern: value) + } +} + +extension UnsafeMutableRawPointer.AtomicRepresentation: AtomicStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + let encoded = Storage.atomicLoad(at: _extract(pointer), ordering: ordering) + return _decode(encoded) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + Storage.atomicStore(_encode(desired), at: _extract(pointer), ordering: ordering) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + _decode(Storage.atomicExchange(_encode(desired), at: _extract(pointer), ordering: ordering)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + ordering: ordering) + return (exchanged, _decode(original)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + 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, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicWeakCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + successOrdering: successOrdering, + failureOrdering: failureOrdering) + return (exchanged, _decode(original)) + } +} +extension UnsafePointer: AtomicValue { + @frozen + public struct AtomicRepresentation { + public typealias Value = UnsafePointer + @usableFromInline internal typealias Storage = Int.AtomicRepresentation + + @usableFromInline + internal let _storage: Storage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = .init(Self._encode(value)) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + Self._decode(_storage.dispose()) + } + } +} + +extension UnsafePointer.AtomicRepresentation { + @_transparent @_alwaysEmitIntoClient + @usableFromInline + internal static func _extract( + _ ptr: UnsafeMutablePointer + ) -> UnsafeMutablePointer { + // `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 { + return UnsafePointer(bitPattern: bitPattern)! + } + + @_transparent @_alwaysEmitIntoClient + internal static func _encode(_ value: Value) -> Int { + return Int(bitPattern: value) + } +} + +extension UnsafePointer.AtomicRepresentation: AtomicStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + let encoded = Storage.atomicLoad(at: _extract(pointer), ordering: ordering) + return _decode(encoded) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + Storage.atomicStore(_encode(desired), at: _extract(pointer), ordering: ordering) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + _decode(Storage.atomicExchange(_encode(desired), at: _extract(pointer), ordering: ordering)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + ordering: ordering) + return (exchanged, _decode(original)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + 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, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicWeakCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + successOrdering: successOrdering, + failureOrdering: failureOrdering) + return (exchanged, _decode(original)) + } +} +extension UnsafeMutablePointer: AtomicValue { + @frozen + public struct AtomicRepresentation { + public typealias Value = UnsafeMutablePointer + @usableFromInline internal typealias Storage = Int.AtomicRepresentation + + @usableFromInline + internal let _storage: Storage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = .init(Self._encode(value)) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + Self._decode(_storage.dispose()) + } + } +} + +extension UnsafeMutablePointer.AtomicRepresentation { + @_transparent @_alwaysEmitIntoClient + @usableFromInline + internal static func _extract( + _ ptr: UnsafeMutablePointer + ) -> UnsafeMutablePointer { + // `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 { + return UnsafeMutablePointer(bitPattern: bitPattern)! + } + + @_transparent @_alwaysEmitIntoClient + internal static func _encode(_ value: Value) -> Int { + return Int(bitPattern: value) + } +} + +extension UnsafeMutablePointer.AtomicRepresentation: AtomicStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + let encoded = Storage.atomicLoad(at: _extract(pointer), ordering: ordering) + return _decode(encoded) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + Storage.atomicStore(_encode(desired), at: _extract(pointer), ordering: ordering) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + _decode(Storage.atomicExchange(_encode(desired), at: _extract(pointer), ordering: ordering)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + ordering: ordering) + return (exchanged, _decode(original)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + 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, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicWeakCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + successOrdering: successOrdering, + failureOrdering: failureOrdering) + return (exchanged, _decode(original)) + } +} +extension Unmanaged: AtomicValue { + @frozen + public struct AtomicRepresentation { + public typealias Value = Unmanaged + @usableFromInline internal typealias Storage = Int.AtomicRepresentation + + @usableFromInline + internal let _storage: Storage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = .init(Self._encode(value)) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + Self._decode(_storage.dispose()) + } + } +} + +extension Unmanaged.AtomicRepresentation { + @_transparent @_alwaysEmitIntoClient + @usableFromInline + internal static func _extract( + _ ptr: UnsafeMutablePointer + ) -> UnsafeMutablePointer { + // `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 { + return Unmanaged.fromOpaque(UnsafeRawPointer(bitPattern: bitPattern)!) + } + + @_transparent @_alwaysEmitIntoClient + internal static func _encode(_ value: Value) -> Int { + return Int(bitPattern: value.toOpaque()) + } +} + +extension Unmanaged.AtomicRepresentation: AtomicStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + let encoded = Storage.atomicLoad(at: _extract(pointer), ordering: ordering) + return _decode(encoded) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + Storage.atomicStore(_encode(desired), at: _extract(pointer), ordering: ordering) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + _decode(Storage.atomicExchange(_encode(desired), at: _extract(pointer), ordering: ordering)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + ordering: ordering) + return (exchanged, _decode(original)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + 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, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicWeakCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + successOrdering: successOrdering, + failureOrdering: failureOrdering) + return (exchanged, _decode(original)) + } +} + + +extension UnsafeRawPointer: AtomicOptionalWrappable { + @frozen + public struct AtomicOptionalRepresentation { + public typealias Value = UnsafeRawPointer? + @usableFromInline internal typealias Storage = Int.AtomicRepresentation + + @usableFromInline + internal let _storage: Storage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = .init(Self._encode(value)) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + Self._decode(_storage.dispose()) + } + } +} + +extension UnsafeRawPointer.AtomicOptionalRepresentation { + @_transparent @_alwaysEmitIntoClient + @usableFromInline + internal static func _extract( + _ ptr: UnsafeMutablePointer + ) -> UnsafeMutablePointer { + // `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 { + return UnsafeRawPointer(bitPattern: bitPattern) + } + + @_transparent @_alwaysEmitIntoClient + internal static func _encode(_ value: Value) -> Int { + guard let value = value else { return 0 } + return Int(bitPattern: value) + } +} + +extension UnsafeRawPointer.AtomicOptionalRepresentation: AtomicStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + let encoded = Storage.atomicLoad(at: _extract(pointer), ordering: ordering) + return _decode(encoded) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + Storage.atomicStore(_encode(desired), at: _extract(pointer), ordering: ordering) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + _decode(Storage.atomicExchange(_encode(desired), at: _extract(pointer), ordering: ordering)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + ordering: ordering) + return (exchanged, _decode(original)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + 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, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicWeakCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + successOrdering: successOrdering, + failureOrdering: failureOrdering) + return (exchanged, _decode(original)) + } +} +extension UnsafeMutableRawPointer: AtomicOptionalWrappable { + @frozen + public struct AtomicOptionalRepresentation { + public typealias Value = UnsafeMutableRawPointer? + @usableFromInline internal typealias Storage = Int.AtomicRepresentation + + @usableFromInline + internal let _storage: Storage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = .init(Self._encode(value)) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + Self._decode(_storage.dispose()) + } + } +} + +extension UnsafeMutableRawPointer.AtomicOptionalRepresentation { + @_transparent @_alwaysEmitIntoClient + @usableFromInline + internal static func _extract( + _ ptr: UnsafeMutablePointer + ) -> UnsafeMutablePointer { + // `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 { + return UnsafeMutableRawPointer(bitPattern: bitPattern) + } + + @_transparent @_alwaysEmitIntoClient + internal static func _encode(_ value: Value) -> Int { + guard let value = value else { return 0 } + return Int(bitPattern: value) + } +} + +extension UnsafeMutableRawPointer.AtomicOptionalRepresentation: AtomicStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + let encoded = Storage.atomicLoad(at: _extract(pointer), ordering: ordering) + return _decode(encoded) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + Storage.atomicStore(_encode(desired), at: _extract(pointer), ordering: ordering) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + _decode(Storage.atomicExchange(_encode(desired), at: _extract(pointer), ordering: ordering)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + ordering: ordering) + return (exchanged, _decode(original)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + 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, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicWeakCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + successOrdering: successOrdering, + failureOrdering: failureOrdering) + return (exchanged, _decode(original)) + } +} +extension UnsafePointer: AtomicOptionalWrappable { + @frozen + public struct AtomicOptionalRepresentation { + public typealias Value = UnsafePointer? + @usableFromInline internal typealias Storage = Int.AtomicRepresentation + + @usableFromInline + internal let _storage: Storage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = .init(Self._encode(value)) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + Self._decode(_storage.dispose()) + } + } +} + +extension UnsafePointer.AtomicOptionalRepresentation { + @_transparent @_alwaysEmitIntoClient + @usableFromInline + internal static func _extract( + _ ptr: UnsafeMutablePointer + ) -> UnsafeMutablePointer { + // `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 { + return UnsafePointer(bitPattern: bitPattern) + } + + @_transparent @_alwaysEmitIntoClient + internal static func _encode(_ value: Value) -> Int { + guard let value = value else { return 0 } + return Int(bitPattern: value) + } +} + +extension UnsafePointer.AtomicOptionalRepresentation: AtomicStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + let encoded = Storage.atomicLoad(at: _extract(pointer), ordering: ordering) + return _decode(encoded) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + Storage.atomicStore(_encode(desired), at: _extract(pointer), ordering: ordering) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + _decode(Storage.atomicExchange(_encode(desired), at: _extract(pointer), ordering: ordering)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + ordering: ordering) + return (exchanged, _decode(original)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + 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, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicWeakCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + successOrdering: successOrdering, + failureOrdering: failureOrdering) + return (exchanged, _decode(original)) + } +} +extension UnsafeMutablePointer: AtomicOptionalWrappable { + @frozen + public struct AtomicOptionalRepresentation { + public typealias Value = UnsafeMutablePointer? + @usableFromInline internal typealias Storage = Int.AtomicRepresentation + + @usableFromInline + internal let _storage: Storage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = .init(Self._encode(value)) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + Self._decode(_storage.dispose()) + } + } +} + +extension UnsafeMutablePointer.AtomicOptionalRepresentation { + @_transparent @_alwaysEmitIntoClient + @usableFromInline + internal static func _extract( + _ ptr: UnsafeMutablePointer + ) -> UnsafeMutablePointer { + // `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 { + return UnsafeMutablePointer(bitPattern: bitPattern) + } + + @_transparent @_alwaysEmitIntoClient + internal static func _encode(_ value: Value) -> Int { + guard let value = value else { return 0 } + return Int(bitPattern: value) + } +} + +extension UnsafeMutablePointer.AtomicOptionalRepresentation: AtomicStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + let encoded = Storage.atomicLoad(at: _extract(pointer), ordering: ordering) + return _decode(encoded) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + Storage.atomicStore(_encode(desired), at: _extract(pointer), ordering: ordering) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + _decode(Storage.atomicExchange(_encode(desired), at: _extract(pointer), ordering: ordering)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + ordering: ordering) + return (exchanged, _decode(original)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + 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, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicWeakCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + successOrdering: successOrdering, + failureOrdering: failureOrdering) + return (exchanged, _decode(original)) + } +} +extension Unmanaged: AtomicOptionalWrappable { + @frozen + public struct AtomicOptionalRepresentation { + public typealias Value = Unmanaged? + @usableFromInline internal typealias Storage = Int.AtomicRepresentation + + @usableFromInline + internal let _storage: Storage + + @inline(__always) @_alwaysEmitIntoClient + public init(_ value: Value) { + self._storage = .init(Self._encode(value)) + } + + @inline(__always) @_alwaysEmitIntoClient + public func dispose() -> Value { + Self._decode(_storage.dispose()) + } + } +} + +extension Unmanaged.AtomicOptionalRepresentation { + @_transparent @_alwaysEmitIntoClient + @usableFromInline + internal static func _extract( + _ ptr: UnsafeMutablePointer + ) -> UnsafeMutablePointer { + // `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 { + guard let opaque = UnsafeRawPointer(bitPattern: bitPattern) else { + return nil + } + return Unmanaged.fromOpaque(opaque) + } + + @_transparent @_alwaysEmitIntoClient + internal static func _encode(_ value: Value) -> Int { + guard let value = value else { return 0 } + return Int(bitPattern: value.toOpaque()) + } +} + +extension Unmanaged.AtomicOptionalRepresentation: AtomicStorage { + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicLoad( + at pointer: UnsafeMutablePointer, + ordering: AtomicLoadOrdering + ) -> Value { + let encoded = Storage.atomicLoad(at: _extract(pointer), ordering: ordering) + return _decode(encoded) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicStore( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicStoreOrdering + ) { + Storage.atomicStore(_encode(desired), at: _extract(pointer), ordering: ordering) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicExchange( + _ desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> Value { + _decode(Storage.atomicExchange(_encode(desired), at: _extract(pointer), ordering: ordering)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + ordering: AtomicUpdateOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + ordering: ordering) + return (exchanged, _decode(original)) + } + + @_semantics("atomics.requires_constant_orderings") + @_transparent @_alwaysEmitIntoClient + public static func atomicCompareExchange( + expected: Value, + desired: Value, + at pointer: UnsafeMutablePointer, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + 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, + successOrdering: AtomicUpdateOrdering, + failureOrdering: AtomicLoadOrdering + ) -> (exchanged: Bool, original: Value) { + let (exchanged, original) = Storage.atomicWeakCompareExchange( + expected: _encode(expected), + desired: _encode(desired), + at: _extract(pointer), + successOrdering: successOrdering, + failureOrdering: failureOrdering) + return (exchanged, _decode(original)) + } +} diff --git a/Sources/_AtomicsShims/include/_AtomicsShims.h b/Sources/_AtomicsShims/include/_AtomicsShims.h new file mode 100644 index 0000000..9d10a2f --- /dev/null +++ b/Sources/_AtomicsShims/include/_AtomicsShims.h @@ -0,0 +1,366 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// + +#ifndef SWIFTATOMIC_HEADER_INCLUDED +#define SWIFTATOMIC_HEADER_INCLUDED 1 + +// Swift-importable shims for C atomics. +// +// Swift cannot import C's atomic types or any operations over them, so we need +// to meticulously wrap all of them in tiny importable types and functions. +// +// This file defines an atomic storage representation and 56 atomic operations +// for each of the 10 standard integer types in the Standard Library, as well as +// Bool and a double-word integer type. To prevent us from having to manually +// write/maintain a thousand or so functions, we use the C preprocessor to stamp +// these out. +// +// Supporting double-wide integers is tricky, because neither Swift nor C has +// standard integer representations for these on platforms where `Int` has a bit +// width of 64. Standard C can model 128-bit atomics through `_Atomic(struct +// pair)` where `pair` is a struct of two `intptr_t`s, but current Swift +// compilers (as of version 5.3) get confused by atomic structs +// (https://reviews.llvm.org/D86218). To work around that, we need to use the +// nonstandard `__uint128_t` type. The Swift compiler does seem to be able to +// deal with `_Atomic(__uint128_t)`, but it refuses to directly import +// `__uint128_t`, so that too needs to be wrapped in a dummy struct (which we +// call `_sa_dword`). We want to stamp out 128-bit atomics from the same code as +// regular atomics, so this requires all atomic operations to distinguish +// between the "exported" C type and the corresponding "internal" +// representation, and to explicitly convert between them as needed. This is +// done using the `SWIFTATOMIC_ENCODE_` and +// `SWIFTATOMIC_DECODE_` family of macros. +// +// In the case of compare-and-exchange, the conversion of the `expected` +// argument needs to go through a temporary stack variable that would result in +// slightly worse codegen for the regular single-word case, so we distinguish +// between `SIMPLE` and `COMPLEX` cmpxchg variants. The single variant assumes +// that the internal representation is identical to the exported type, and does +// away with the comparisons. +// +// FIXME: Upgrading from the preprocessor to gyb would perhaps make things more +// readable here. +// +// FIXME: Eliminate the encoding/decoding mechanism once the package requires a +// compiler that includes https://reviews.llvm.org/D86218. + + +#include +#include +#include +#include + +#define SWIFTATOMIC_INLINE static inline __attribute__((__always_inline__)) +#define SWIFTATOMIC_SWIFT_NAME(name) __attribute__((swift_name(#name))) + +// Atomic fences +#define SWIFTATOMIC_THREAD_FENCE_FN(order) \ + SWIFTATOMIC_INLINE void _sa_thread_fence_##order(void) \ + { \ + atomic_thread_fence(memory_order_##order); \ + } + +SWIFTATOMIC_THREAD_FENCE_FN(acquire) +SWIFTATOMIC_THREAD_FENCE_FN(release) +SWIFTATOMIC_THREAD_FENCE_FN(acq_rel) +SWIFTATOMIC_THREAD_FENCE_FN(seq_cst) + +// Definition of an atomic storage type. +#define SWIFTATOMIC_STORAGE_TYPE(swiftType, cType, storageType) \ + typedef struct { \ + _Atomic(storageType) value; \ + } _sa_##swiftType \ + SWIFTATOMIC_SWIFT_NAME(_Atomic##swiftType##Storage); + +// Storage value initializer +#define SWIFTATOMIC_PREPARE_FN(swiftType, cType, storageType) \ + SWIFTATOMIC_INLINE \ + _sa_##swiftType _sa_prepare_##swiftType(cType value) \ + { \ + _sa_##swiftType storage = { SWIFTATOMIC_ENCODE_##swiftType(value) }; \ + assert(atomic_is_lock_free(&storage.value)); \ + return storage; \ + } + +// Storage value disposal function +#define SWIFTATOMIC_DISPOSE_FN(swiftType, cType, storageType) \ + SWIFTATOMIC_INLINE \ + cType _sa_dispose_##swiftType(_sa_##swiftType storage) \ + { \ + return SWIFTATOMIC_DECODE_##swiftType(storage.value); \ + } + +// Atomic load +#define SWIFTATOMIC_LOAD_FN(swiftType, cType, storageType, order) \ + SWIFTATOMIC_INLINE \ + cType _sa_load_##order##_##swiftType( \ + _sa_##swiftType *ptr) \ + { \ + return SWIFTATOMIC_DECODE_##swiftType( \ + atomic_load_explicit(&ptr->value, \ + memory_order_##order)); \ + } + +// Atomic store +#define SWIFTATOMIC_STORE_FN(swiftType, cType, storageType, order) \ + SWIFTATOMIC_INLINE \ + void _sa_store_##order##_##swiftType( \ + _sa_##swiftType *ptr, \ + cType desired) \ + { \ + atomic_store_explicit(&ptr->value, \ + SWIFTATOMIC_ENCODE_##swiftType(desired), \ + memory_order_##order); \ + } + +// Atomic exchange +#define SWIFTATOMIC_EXCHANGE_FN(swiftType, cType, storageType, order) \ + SWIFTATOMIC_INLINE \ + cType _sa_exchange_##order##_##swiftType( \ + _sa_##swiftType *ptr, \ + cType desired) \ + { \ + return SWIFTATOMIC_DECODE_##swiftType( \ + atomic_exchange_explicit( \ + &ptr->value, \ + SWIFTATOMIC_ENCODE_##swiftType(desired), \ + memory_order_##order)); \ + } + +// Atomic compare/exchange +#define SWIFTATOMIC_CMPXCHG_FN_SIMPLE(_kind, swiftType, cType, storageType, succ, fail) \ + SWIFTATOMIC_INLINE \ + bool \ + _sa_cmpxchg_##_kind##_##succ##_##fail##_##swiftType( \ + _sa_##swiftType *ptr, \ + cType *expected, \ + cType desired) \ + { \ + return atomic_compare_exchange_##_kind##_explicit( \ + &ptr->value, \ + expected, \ + desired, \ + memory_order_##succ, \ + memory_order_##fail); \ + } + +#define SWIFTATOMIC_CMPXCHG_FN_COMPLEX(_kind, swiftType, cType, storageType, succ, fail) \ + SWIFTATOMIC_INLINE \ + bool \ + _sa_cmpxchg_##_kind##_##succ##_##fail##_##swiftType( \ + _sa_##swiftType *ptr, \ + cType *expected, \ + cType desired) \ + { \ + storageType _expected = SWIFTATOMIC_ENCODE_##swiftType(*expected); \ + bool result = atomic_compare_exchange_##_kind##_explicit( \ + &ptr->value, \ + &_expected, \ + SWIFTATOMIC_ENCODE_##swiftType(desired), \ + memory_order_##succ, \ + memory_order_##fail); \ + *expected = SWIFTATOMIC_DECODE_##swiftType(_expected); \ + return result; \ + } + +// Atomic integer operations +#define SWIFTATOMIC_INTEGER_FN(op, swiftType, cType, storageType, order) \ + SWIFTATOMIC_INLINE \ + cType _sa_fetch_##op##_##order##_##swiftType( \ + _sa_##swiftType *ptr, \ + cType operand) \ + { \ + return SWIFTATOMIC_DECODE_##swiftType( \ + atomic_fetch_##op##_explicit( \ + &ptr->value, \ + SWIFTATOMIC_ENCODE_##swiftType(operand), \ + memory_order_##order)); \ + } + +// Functions for each supported operation + memory ordering combination +#define SWIFTATOMIC_STORE_FNS(swiftType, cType, storageType) \ + SWIFTATOMIC_STORE_FN(swiftType, cType, storageType, relaxed) \ + SWIFTATOMIC_STORE_FN(swiftType, cType, storageType, release) \ + SWIFTATOMIC_STORE_FN(swiftType, cType, storageType, seq_cst) + +#define SWIFTATOMIC_LOAD_FNS(swiftType, cType, storageType) \ + SWIFTATOMIC_LOAD_FN(swiftType, cType, storageType, relaxed) \ + SWIFTATOMIC_LOAD_FN(swiftType, cType, storageType, acquire) \ + SWIFTATOMIC_LOAD_FN(swiftType, cType, storageType, seq_cst) + +#define SWIFTATOMIC_EXCHANGE_FNS(swiftType, cType, storageType) \ + SWIFTATOMIC_EXCHANGE_FN(swiftType, cType, storageType, relaxed) \ + SWIFTATOMIC_EXCHANGE_FN(swiftType, cType, storageType, acquire) \ + SWIFTATOMIC_EXCHANGE_FN(swiftType, cType, storageType, release) \ + SWIFTATOMIC_EXCHANGE_FN(swiftType, cType, storageType, acq_rel) \ + SWIFTATOMIC_EXCHANGE_FN(swiftType, cType, storageType, seq_cst) + +#define SWIFTATOMIC_CMPXCHG_FNS(variant, kind, swiftType, cType, storageType) \ + SWIFTATOMIC_CMPXCHG_FN_##variant(kind, swiftType, cType, storageType, relaxed, relaxed) \ + SWIFTATOMIC_CMPXCHG_FN_##variant(kind, swiftType, cType, storageType, acquire, relaxed) \ + SWIFTATOMIC_CMPXCHG_FN_##variant(kind, swiftType, cType, storageType, release, relaxed) \ + SWIFTATOMIC_CMPXCHG_FN_##variant(kind, swiftType, cType, storageType, acq_rel, relaxed) \ + SWIFTATOMIC_CMPXCHG_FN_##variant(kind, swiftType, cType, storageType, seq_cst, relaxed) \ + SWIFTATOMIC_CMPXCHG_FN_##variant(kind, swiftType, cType, storageType, acquire, acquire) \ + SWIFTATOMIC_CMPXCHG_FN_##variant(kind, swiftType, cType, storageType, acq_rel, acquire) \ + SWIFTATOMIC_CMPXCHG_FN_##variant(kind, swiftType, cType, storageType, seq_cst, acquire) \ + SWIFTATOMIC_CMPXCHG_FN_##variant(kind, swiftType, cType, storageType, seq_cst, seq_cst) + +#define SWIFTATOMIC_INTEGER_FNS(op, swiftType, cType, storageType) \ + SWIFTATOMIC_INTEGER_FN(op, swiftType, cType, storageType, relaxed) \ + SWIFTATOMIC_INTEGER_FN(op, swiftType, cType, storageType, acquire) \ + SWIFTATOMIC_INTEGER_FN(op, swiftType, cType, storageType, release) \ + SWIFTATOMIC_INTEGER_FN(op, swiftType, cType, storageType, acq_rel) \ + SWIFTATOMIC_INTEGER_FN(op, swiftType, cType, storageType, seq_cst) + +#define SWIFTATOMIC_DEFINE_TYPE(variant, swiftType, cType, storageType) \ + SWIFTATOMIC_STORAGE_TYPE(swiftType, cType, storageType) \ + SWIFTATOMIC_PREPARE_FN(swiftType, cType, storageType) \ + SWIFTATOMIC_DISPOSE_FN(swiftType, cType, storageType) \ + SWIFTATOMIC_LOAD_FNS(swiftType, cType, storageType) \ + SWIFTATOMIC_STORE_FNS(swiftType, cType, storageType) \ + SWIFTATOMIC_EXCHANGE_FNS(swiftType, cType, storageType) \ + SWIFTATOMIC_CMPXCHG_FNS(variant, strong, swiftType, cType, storageType) \ + SWIFTATOMIC_CMPXCHG_FNS(variant, weak, swiftType, cType, storageType) + +#define SWIFTATOMIC_DEFINE_INTEGER_TYPE(variant, swiftType, cType, storageType) \ + SWIFTATOMIC_DEFINE_TYPE(variant, swiftType, cType, storageType) \ + SWIFTATOMIC_INTEGER_FNS(add, swiftType, cType, storageType) \ + SWIFTATOMIC_INTEGER_FNS(sub, swiftType, cType, storageType) \ + SWIFTATOMIC_INTEGER_FNS(or, swiftType, cType, storageType) \ + SWIFTATOMIC_INTEGER_FNS(xor, swiftType, cType, storageType) \ + SWIFTATOMIC_INTEGER_FNS(and, swiftType, cType, storageType) + +// All known integer types +#define SWIFTATOMIC_ENCODE_Int(value) (value) +#define SWIFTATOMIC_DECODE_Int(value) (value) +SWIFTATOMIC_DEFINE_INTEGER_TYPE(SIMPLE, Int, intptr_t, intptr_t) + +#define SWIFTATOMIC_ENCODE_Int8(value) (value) +#define SWIFTATOMIC_DECODE_Int8(value) (value) +SWIFTATOMIC_DEFINE_INTEGER_TYPE(SIMPLE, Int8, int8_t, int8_t) + +#define SWIFTATOMIC_ENCODE_Int16(value) (value) +#define SWIFTATOMIC_DECODE_Int16(value) (value) +SWIFTATOMIC_DEFINE_INTEGER_TYPE(SIMPLE, Int16, int16_t, int16_t) + +#define SWIFTATOMIC_ENCODE_Int32(value) (value) +#define SWIFTATOMIC_DECODE_Int32(value) (value) +SWIFTATOMIC_DEFINE_INTEGER_TYPE(SIMPLE, Int32, int32_t, int32_t) + +#define SWIFTATOMIC_ENCODE_Int64(value) (value) +#define SWIFTATOMIC_DECODE_Int64(value) (value) +SWIFTATOMIC_DEFINE_INTEGER_TYPE(SIMPLE, Int64, int64_t, int64_t) + +#define SWIFTATOMIC_ENCODE_UInt(value) (value) +#define SWIFTATOMIC_DECODE_UInt(value) (value) +SWIFTATOMIC_DEFINE_INTEGER_TYPE(SIMPLE, UInt, uintptr_t, uintptr_t) + +#define SWIFTATOMIC_ENCODE_UInt8(value) (value) +#define SWIFTATOMIC_DECODE_UInt8(value) (value) +SWIFTATOMIC_DEFINE_INTEGER_TYPE(SIMPLE, UInt8, uint8_t, uint8_t) + +#define SWIFTATOMIC_ENCODE_UInt16(value) (value) +#define SWIFTATOMIC_DECODE_UInt16(value) (value) +SWIFTATOMIC_DEFINE_INTEGER_TYPE(SIMPLE, UInt16, uint16_t, uint16_t) + +#define SWIFTATOMIC_ENCODE_UInt32(value) (value) +#define SWIFTATOMIC_DECODE_UInt32(value) (value) +SWIFTATOMIC_DEFINE_INTEGER_TYPE(SIMPLE, UInt32, uint32_t, uint32_t) + +#define SWIFTATOMIC_ENCODE_UInt64(value) (value) +#define SWIFTATOMIC_DECODE_UInt64(value) (value) +SWIFTATOMIC_DEFINE_INTEGER_TYPE(SIMPLE, UInt64, uint64_t, uint64_t) + +// Atomic boolean +#define SWIFTATOMIC_ENCODE_Bool(value) (value) +#define SWIFTATOMIC_DECODE_Bool(value) (value) +SWIFTATOMIC_DEFINE_TYPE(SIMPLE, Bool, bool, bool) +SWIFTATOMIC_INTEGER_FNS(or, Bool, bool, bool) +SWIFTATOMIC_INTEGER_FNS(xor, Bool, bool, bool) +SWIFTATOMIC_INTEGER_FNS(and, Bool, bool, bool) + +// Double wide atomics (__uint128_t on 64-bit platforms, uint64_t elsewhere) +#if __INTPTR_WIDTH__ == 64 +#if !defined(__SIZEOF_INT128__) +#error "Double wide atomics need __uint128_t" +#endif +typedef struct { + __uint128_t value; +} _sa_dword SWIFTATOMIC_SWIFT_NAME(DoubleWord); + +SWIFTATOMIC_INLINE +_sa_dword _sa_dword_create(uintptr_t high, uintptr_t low) { + _sa_dword result = { ((__uint128_t)high << 64) | (__uint128_t)low }; + return result; +} + +SWIFTATOMIC_INLINE +uintptr_t _sa_dword_extract_high(_sa_dword value) { + return (uintptr_t)(value.value >> 64); +} + +SWIFTATOMIC_INLINE +uintptr_t _sa_dword_extract_low(_sa_dword value) { + return (uintptr_t)value.value; +} + +SWIFTATOMIC_INLINE +_sa_dword _sa_decode_dword(__uint128_t value) { + _sa_dword result = { value }; + return result; +} + +#define SWIFTATOMIC_ENCODE_DoubleWord(_value) (_value).value +#define SWIFTATOMIC_DECODE_DoubleWord(value) _sa_decode_dword(value) +SWIFTATOMIC_DEFINE_TYPE(COMPLEX, DoubleWord, _sa_dword, __uint128_t) + +#elif __INTPTR_WIDTH__ == 32 + +typedef struct { + uint64_t value; +} _sa_dword SWIFTATOMIC_SWIFT_NAME(DoubleWord); + +SWIFTATOMIC_INLINE +_sa_dword _sa_dword_create(uintptr_t high, uintptr_t low) { + _sa_dword result = { ((uint64_t)high << 32) | (uint64_t)low }; + return result; +} + +SWIFTATOMIC_INLINE +uintptr_t _sa_dword_extract_high(_sa_dword value) { + return (uintptr_t)(value.value >> 32); +} + +SWIFTATOMIC_INLINE +uintptr_t _sa_dword_extract_low(_sa_dword value) { + return (uintptr_t)value.value; +} + +SWIFTATOMIC_INLINE +_sa_dword _sa_decode_dword(uint64_t value) { + _sa_dword result = { value }; + return result; +} + +#define SWIFTATOMIC_ENCODE_DoubleWord(_value) (_value).value +#define SWIFTATOMIC_DECODE_DoubleWord(value) _sa_decode_dword(value) +SWIFTATOMIC_DEFINE_TYPE(COMPLEX, DoubleWord, _sa_dword, uint64_t) + +#else +#error "Unsupported intptr_t bit width" +#endif // __INTPTR_WIDTH + +extern void _sa_retain_n(void *object, uint32_t n); +extern void _sa_release_n(void *object, uint32_t n); + +#endif //SWIFTATOMIC_HEADER_INCLUDED diff --git a/Sources/_AtomicsShims/src/_AtomicsShims.c b/Sources/_AtomicsShims/src/_AtomicsShims.c new file mode 100644 index 0000000..39a744b --- /dev/null +++ b/Sources/_AtomicsShims/src/_AtomicsShims.c @@ -0,0 +1,23 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// + +#include "_AtomicsShims.h" + +void _sa_retain_n(void *object, uint32_t n) { + extern void *swift_retain_n(void *object, uint32_t n); + swift_retain_n(object, n); +} + +void _sa_release_n(void *object, uint32_t n) { + extern void swift_release_n(void *object, uint32_t n); + swift_release_n(object, n); +} diff --git a/Tests/AtomicsTests/Basics.swift.gyb b/Tests/AtomicsTests/Basics.swift.gyb new file mode 100644 index 0000000..31bd72e --- /dev/null +++ b/Tests/AtomicsTests/Basics.swift.gyb @@ -0,0 +1,369 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// + +%{ + from gyb_utils import ( + autogenerated_warning, loadOrderings, storeOrderings, updateOrderings, + boolOperations, integerOperations, lowerFirst, argLabel) + + types = [ + ("Int", "Int", "12", "23"), + ("Int8", "Int8", "12", "23"), + ("Int16", "Int16", "12", "23"), + ("Int32", "Int32", "12", "23"), + ("Int64", "Int64", "12", "23"), + ("UInt", "UInt", "12", "23"), + ("UInt8", "UInt8", "12", "23"), + ("UInt16", "UInt16", "12", "23"), + ("UInt32", "UInt32", "12", "23"), + ("UInt64", "UInt64", "12", "23"), + + ("Bool", "Bool", "true", "false"), + ("DoubleWord", "DoubleWord", "DoubleWord(high: 100, low: 64)", "DoubleWord(high: 50, low: 32)"), + + ("Pointer", "UnsafePointer", "_foo1", "_foo2"), + ("OptionalPointer", "UnsafePointer?", "nil", "_foo2"), + ("MutablePointer", "UnsafeMutablePointer", "_mfoo1", "_mfoo2"), + ("OptionalMutablePointer", "UnsafeMutablePointer?", "nil", "_mfoo2"), + ("RawPointer", "UnsafeMutableRawPointer", "_raw1", "_raw2"), + ("OptionalRawPointer", "UnsafeMutableRawPointer?", "nil", "_raw2"), + + ("Unmanaged", "Unmanaged", "_bar1", "_bar2"), + ("OptionalUnmanaged", "Unmanaged?", "nil", "_bar2"), + + ("Reference", "Baz", "_baz1", "_baz2"), + ("OptionalReference", "Baz?", "nil", "_baz2"), + + ("RawRepresentable", "Fred", "Fred.one", "Fred.two"), + ] +}% +${autogenerated_warning()} + +import XCTest +import Atomics + +extension Unmanaged: Equatable { // FIXME: This is terrible + public static func ==(left: Self, right: Self) -> Bool { + left.toOpaque() == right.toOpaque() + } +} + +private struct Foo: Equatable, CustomStringConvertible { + var value: Int + init(_ value: Int) { self.value = value } + var description: String { "Foo(\(value))" } +} + +private class Bar: Equatable, CustomStringConvertible { + var value: Int + init(_ value: Int) { self.value = value } + var description: String { "Bar(\(value))" } + static func ==(left: Bar, right: Bar) -> Bool { + left === right + } +} + +private class Baz: Equatable, CustomStringConvertible, AtomicReference { + var value: Int + init(_ value: Int) { self.value = value } + var description: String { "Bar(\(value))" } + static func ==(left: Baz, right: Baz) -> Bool { + left === right + } +} + +private enum Fred: Int, AtomicValue { + case one + case two +} + +/// Exercises all operations in a single-threaded context, verifying +/// they provide the expected results. +class BasicAtomicTests: XCTestCase { + private let _mfoo1: UnsafeMutablePointer = { + let p = UnsafeMutablePointer.allocate(capacity: 1) + p.initialize(to: Foo(1)) + return p + }() + + private let _mfoo2: UnsafeMutablePointer = { + let p = UnsafeMutablePointer.allocate(capacity: 1) + p.initialize(to: Foo(2)) + return p + }() + + private var _foo1: UnsafePointer { UnsafePointer(_mfoo1) } + private var _foo2: UnsafePointer { UnsafePointer(_mfoo2) } + + private let _raw1 = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1) + private let _raw2 = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1) + private let _bar1 = Unmanaged.passRetained(Bar(1)) + private let _bar2 = Unmanaged.passRetained(Bar(2)) + private let _baz1 = Baz(1) + private let _baz2 = Baz(2) + + deinit { + _mfoo1.deinitialize(count: 1) + _mfoo1.deallocate() + + _mfoo2.deinitialize(count: 1) + _mfoo2.deallocate() + + _raw1.deallocate() + _raw2.deallocate() + + _bar1.release() + _bar2.release() + } + +% for label, type, a, b in types: + func test_${label}_create_destroy() { + let v = UnsafeAtomic<${type}>.create(${a}) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), ${a}) + + let w = UnsafeAtomic<${type}>.create(${b}) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), ${b}) + } + +% for (order, _) in loadOrderings: + func test_${label}_load_${order}() { + let v = UnsafeAtomic<${type}>.create(${a}) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .${order}), ${a}) + + let w = UnsafeAtomic<${type}>.create(${b}) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .${order}), ${b}) + } +% end + +% for (order, _) in storeOrderings: + func test_${label}_store_${order}() { + let v = UnsafeAtomic<${type}>.create(${a}) + defer { v.destroy() } + v.store(${b}, ordering: .${order}) + XCTAssertEqual(v.load(ordering: .relaxed), ${b}) + + let w = UnsafeAtomic<${type}>.create(${b}) + defer { w.destroy() } + w.store(${a}, ordering: .${order}) + XCTAssertEqual(w.load(ordering: .relaxed), ${a}) + } +% end + +% for (order, _, _) in updateOrderings: + func test_${label}_exchange_${order}() { + let v = UnsafeAtomic<${type}>.create(${a}) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(${a}, ordering: .${order}), ${a}) + XCTAssertEqual(v.load(ordering: .relaxed), ${a}) + + XCTAssertEqual(v.exchange(${b}, ordering: .${order}), ${a}) + XCTAssertEqual(v.load(ordering: .relaxed), ${b}) + + XCTAssertEqual(v.exchange(${b}, ordering: .${order}), ${b}) + XCTAssertEqual(v.load(ordering: .relaxed), ${b}) + } +% end + +% for (order, _, _) in updateOrderings: + func test_${label}_compareExchange_${order}() { + let v = UnsafeAtomic<${type}>.create(${a}) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: ${a}, + desired: ${b}, + ordering: .${order}) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, ${a}) + XCTAssertEqual(v.load(ordering: .relaxed), ${b}) + + (exchanged, original) = v.compareExchange( + expected: ${a}, + desired: ${b}, + ordering: .${order}) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, ${b}) + XCTAssertEqual(v.load(ordering: .relaxed), ${b}) + + (exchanged, original) = v.compareExchange( + expected: ${b}, + desired: ${a}, + ordering: .${order}) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, ${b}) + XCTAssertEqual(v.load(ordering: .relaxed), ${a}) + + (exchanged, original) = v.compareExchange( + expected: ${b}, + desired: ${a}, + ordering: .${order}) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, ${a}) + XCTAssertEqual(v.load(ordering: .relaxed), ${a}) + } +% end + +% for operation in ["compareExchange", "weakCompareExchange"]: +% for (successorder, _, _) in updateOrderings: +% for (failorder, _) in loadOrderings: + func test_${label}_${operation}_${successorder}_${failorder}() { + let v = UnsafeAtomic<${type}>.create(${a}) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: ${a}, + desired: ${b}, + successOrdering: .${successorder}, + failureOrdering: .${failorder}) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, ${a}) + XCTAssertEqual(v.load(ordering: .relaxed), ${b}) + + (exchanged, original) = v.compareExchange( + expected: ${a}, + desired: ${b}, + successOrdering: .${successorder}, + failureOrdering: .${failorder}) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, ${b}) + XCTAssertEqual(v.load(ordering: .relaxed), ${b}) + + (exchanged, original) = v.compareExchange( + expected: ${b}, + desired: ${a}, + successOrdering: .${successorder}, + failureOrdering: .${failorder}) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, ${b}) + XCTAssertEqual(v.load(ordering: .relaxed), ${a}) + + (exchanged, original) = v.compareExchange( + expected: ${b}, + desired: ${a}, + successOrdering: .${successorder}, + failureOrdering: .${failorder}) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, ${a}) + XCTAssertEqual(v.load(ordering: .relaxed), ${a}) + } +% end +% end +% end + + +// Bool operations + +% if type == "Bool": +% for (name, _, operator, arglabel, _) in boolOperations: +% for (order, _, _) in updateOrderings: + func test_${label}_loadThen${name}_${order}() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.loadThen${name}(${argLabel(arglabel)}b, ordering: .${order}) + XCTAssertEqual(r, a, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a ${operator} b, + "a = \(a), b =\(b)") + } + } + } +% end +% end + +% for (name, _, operator, arglabel, _) in boolOperations: +% for (order, _, _) in updateOrderings: + func test_${label}_${lowerFirst(name)}ThenLoad_${order}() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.${lowerFirst(name)}ThenLoad( + ${argLabel(arglabel)}b, + ordering: .${order}) + XCTAssertEqual(r, a ${operator} b, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a ${operator} b, + "a = \(a), b =\(b)") + } + } + } +% end +% end +% end + +// Integer operations + +% if type.startswith("Int") or type.startswith("UInt"): +% for (name, _, operator, arglabel, _) in integerOperations: +% for (order, _, _) in updateOrderings: + func test_${label}_loadThen${name}_${order}() { + let a: ${type} = 3 + let b: ${type} = 8 + let c: ${type} = 12 + let result1: ${type} = a ${operator} b + let result2: ${type} = result1 ${operator} c + + let v = UnsafeAtomic<${type}>.create(a) + defer { v.destroy() } + + let old1 = v.loadThen${name}(${argLabel(arglabel)}b, ordering: .${order}) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThen${name}(${argLabel(arglabel)}c, ordering: .${order}) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } +% end +% end + +% for (name, _, operator, arglabel, _) in integerOperations: +% for (order, _, _) in updateOrderings: + func test_${label}_${lowerFirst(name)}ThenLoad_${order}() { + let a: ${type} = 3 + let b: ${type} = 8 + let c: ${type} = 12 + let result1: ${type} = a ${operator} b + let result2: ${type} = result1 ${operator} c + + let v = UnsafeAtomic<${type}>.create(a) + defer { v.destroy() } + + let new1 = v.${lowerFirst(name)}ThenLoad(${argLabel(arglabel)}b, ordering: .${order}) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.${lowerFirst(name)}ThenLoad(${argLabel(arglabel)}c, ordering: .${order}) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } +% end +% end +% end + +% end +} diff --git a/Tests/AtomicsTests/DoubleWord.swift b/Tests/AtomicsTests/DoubleWord.swift new file mode 100644 index 0000000..da88ff6 --- /dev/null +++ b/Tests/AtomicsTests/DoubleWord.swift @@ -0,0 +1,89 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 XCTest +import Atomics + +class DoubleWordTests: XCTestCase { + func testMemoryLayout() { + XCTAssertEqual(MemoryLayout.size, 2 * MemoryLayout.size) + XCTAssertEqual(MemoryLayout.stride, MemoryLayout.size) + XCTAssertEqual(MemoryLayout.alignment, 2 * MemoryLayout.alignment) + } + + struct UIntPair: Equatable { + var first: UInt + var second: UInt + + init(_ first: UInt, _ second: UInt) { + self.first = first + self.second = second + } + } + + func componentsInMemoryOrder(of dword: DoubleWord) -> UIntPair { + let p = UnsafeMutableRawPointer.allocate( + byteCount: MemoryLayout.size, + alignment: MemoryLayout.alignment) + p.storeBytes(of: dword, as: DoubleWord.self) + let first = p.load(as: UInt.self) + let second = p.load(fromByteOffset: MemoryLayout.stride, as: UInt.self) + return UIntPair(first, second) + } + + func testFirstSecondInitializer() { + let value = DoubleWord(first: 1, second: 2) + XCTAssertEqual(componentsInMemoryOrder(of: value), UIntPair(1, 2)) + } + + func testHighLowInitializer() { + let value = DoubleWord(high: 1, low: 2) + #if _endian(little) + XCTAssertEqual(componentsInMemoryOrder(of: value), UIntPair(2, 1)) + #else + XCTAssertEqual(componentsInMemoryOrder(of: value), UIntPair(1, 2)) + #endif + } + + func testPropertyGetters() { + let value = DoubleWord(first: UInt.max, second: 0) + XCTAssertEqual(value.first, UInt.max) + XCTAssertEqual(value.second, 0) + #if _endian(little) + XCTAssertEqual(value.high, 0) + XCTAssertEqual(value.low, UInt.max) + #else + XCTAssertEqual(value.high, UInt.max) + XCTAssertEqual(value.low, 0) + #endif + } + + func testPropertySetters() { + var value = DoubleWord(first: 1, second: 2) + value.first = 3 + XCTAssertEqual(componentsInMemoryOrder(of: value), UIntPair(3, 2)) + value.second = 4 + XCTAssertEqual(componentsInMemoryOrder(of: value), UIntPair(3, 4)) + value.low = 5 + #if _endian(little) + XCTAssertEqual(componentsInMemoryOrder(of: value), UIntPair(5, 4)) + #else + XCTAssertEqual(componentsInMemoryOrder(of: value), UIntPair(3, 5)) + #endif + value.high = 6 + #if _endian(little) + XCTAssertEqual(componentsInMemoryOrder(of: value), UIntPair(5, 6)) + #else + XCTAssertEqual(componentsInMemoryOrder(of: value), UIntPair(6, 5)) + #endif + } +} diff --git a/Tests/AtomicsTests/LifetimeTracked.swift b/Tests/AtomicsTests/LifetimeTracked.swift new file mode 100644 index 0000000..c2e02d6 --- /dev/null +++ b/Tests/AtomicsTests/LifetimeTracked.swift @@ -0,0 +1,78 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics open source project +// +// Copyright (c) 2014 - 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 +// +//===----------------------------------------------------------------------===// + +/// A type that tracks the number of live instances. +/// +/// To be useful in more contexts, `LifetimeTracked` conforms to various +/// protocols in trivial ways. +/// +/// `LifetimeTracked` is useful to check for leaks in algorithms and data +/// structures. `StdlibUnittest` harness automatically checks that after each +/// test has done executing, no `LifetimeTracked` instances exist. +public final class LifetimeTracked { + public init(_ value: Int, identity: Int = 0) { + LifetimeTracked.instances += 1 + LifetimeTracked._nextSerialNumber += 1 + serialNumber = LifetimeTracked._nextSerialNumber + self.value = value + self.identity = identity + } + + deinit { + assert(serialNumber > 0, "double destruction!") + LifetimeTracked.instances -= 1 + serialNumber = -serialNumber + } + + public static var instances: Int = 0 + internal static var _nextSerialNumber = 0 + + public let value: Int + public var identity: Int + public var serialNumber: Int = 0 +} + +extension LifetimeTracked : Equatable { + public static func == (x: LifetimeTracked, y: LifetimeTracked) -> Bool { + return x.value == y.value + } +} + +extension LifetimeTracked : Hashable { + public var hashValue: Int { + return value + } + public func hash(into hasher: inout Hasher) { + hasher.combine(value) + } +} + +extension LifetimeTracked : Strideable { + public func distance(to other: LifetimeTracked) -> Int { + return self.value.distance(to: other.value) + } + + public func advanced(by n: Int) -> LifetimeTracked { + return LifetimeTracked(self.value.advanced(by: n)) + } +} + +extension LifetimeTracked : CustomStringConvertible { + public var description: String { + assert(serialNumber > 0, "dead Tracked!") + return value.description + } +} + +public func < (x: LifetimeTracked, y: LifetimeTracked) -> Bool { + return x.value < y.value +} diff --git a/Tests/AtomicsTests/LockFreeQueue.swift b/Tests/AtomicsTests/LockFreeQueue.swift new file mode 100644 index 0000000..bfc0b56 --- /dev/null +++ b/Tests/AtomicsTests/LockFreeQueue.swift @@ -0,0 +1,171 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// + +// A lock-free concurrent queue implementation adapted from +// M. Michael and M. Scott's 1996 paper [Michael 1996]. +// +// [Michael 1996]: https://doi.org/10.1145/248052.248106 +// +// While this is a nice illustration of the use of atomic strong references, +// this is a somewhat sloppy implementation of an old algorithm. If you need a +// lock-free queue for actual production use, it would probably be a good idea +// to look at some more recent algorithms before deciding on this one. +// +// Note: because this implementation uses reference counting, we don't need +// to implement a free list to resolve the original algorithm's use-after-free +// problem. + +import XCTest +import Dispatch +import Atomics + +class LockFreeQueue { + class Node: AtomicReference { + let next: ManagedAtomic + var value: Element? + + init(value: Element?, next: Node?) { + self.value = value + self.next = ManagedAtomic(next) + } + + deinit { + var values = 0 + // Prevent stack overflow when reclaiming a long queue + var node = self.next.exchange(nil, ordering: .relaxed) + while node != nil && isKnownUniquelyReferenced(&node) { + let next = node!.next.exchange(nil, ordering: .relaxed) + withExtendedLifetime(node) { + values += 1 + } + node = next + } + if values > 0 { + print(values) + } + } + } + + let head: ManagedAtomic + let tail: ManagedAtomic + + // Used to distinguish removed nodes from active nodes with a nil `next`. + let marker = Node(value: nil, next: nil) + + init() { + let dummy = Node(value: nil, next: nil) + self.head = ManagedAtomic(dummy) + self.tail = ManagedAtomic(dummy) + } + + func enqueue(_ newValue: Element) { + let new = Node(value: newValue, next: nil) + + var tail = self.tail.load(ordering: .acquiring) + while true { + let next = tail.next.load(ordering: .acquiring) + if tail === marker || next === marker { + // The node we loaded has been unlinked by a dequeue on another thread. + // Try again. + tail = self.tail.load(ordering: .acquiring) + continue + } + if let next = next { + // Assist competing threads by nudging `self.tail` forward a step. + let (exchanged, original) = self.tail.compareExchange( + expected: tail, + desired: next, + ordering: .acquiringAndReleasing) + tail = (exchanged ? next : original) + continue + } + let (exchanged, current) = tail.next.compareExchange( + expected: nil, + desired: new, + ordering: .acquiringAndReleasing + ) + if exchanged { + _ = self.tail.compareExchange(expected: tail, desired: new, ordering: .releasing) + return + } + tail = current! + } + } + + func dequeue() -> Element? { + while true { + let head = self.head.load(ordering: .acquiring) + let next = head.next.load(ordering: .acquiring) + if next === marker { continue } + guard let n = next else { return nil } + let tail = self.tail.load(ordering: .acquiring) + if head === tail { + // Nudge `tail` forward a step to make sure it doesn't fall off the + // list when we unlink this node. + _ = self.tail.compareExchange(expected: tail, desired: n, ordering: .acquiringAndReleasing) + } + if self.head.compareExchange(expected: head, desired: n, ordering: .releasing).exchanged { + let result = n.value! + n.value = nil + // To prevent threads that are suspended in `enqueue`/`dequeue` from + // holding onto arbitrarily long chains of removed nodes, we unlink + // removed nodes by replacing their `next` value with the special + // `marker`. + head.next.store(marker, ordering: .releasing) + return result + } + } + } +} + +class QueueTests: XCTestCase { + func check(readers: Int, writers: Int, count: Int) { + let queue = LockFreeQueue<(writer: Int, value: Int)>() + let num = ManagedAtomic(0) + DispatchQueue.concurrentPerform(iterations: writers + readers) { id in + if id < writers { + // Writer + for i in 0 ..< count { + queue.enqueue((id, i)) + } + } else { + // Reader + var values = (0 ..< writers).map { _ in -1 } + while num.load(ordering: .relaxed) < writers * count { + // Spin until we get a value + guard let (writer, value) = queue.dequeue() else { continue } + precondition(writer >= 0 && writer < writers) + precondition(readers == 1 ? value == values[writer] + 1 : value > values[writer]) + values[writer] = value + num.wrappingIncrement(ordering: .relaxed) + } + } + } + } + + func test01_10() { + check(readers: 1, writers: 10, count: 1_000_000) + } + + func test02_10() { + check(readers: 2, writers: 10, count: 1_000_000) + } + + func test04_10() { + check(readers: 2, writers: 10, count: 1_000_000) + } + + func test16_16() { + check(readers: 16, writers: 16, count: 1_000_000) + } +} + diff --git a/Tests/AtomicsTests/LockFreeSingleConsumerStack.swift b/Tests/AtomicsTests/LockFreeSingleConsumerStack.swift new file mode 100644 index 0000000..ff1c295 --- /dev/null +++ b/Tests/AtomicsTests/LockFreeSingleConsumerStack.swift @@ -0,0 +1,145 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 XCTest +import Atomics +import Dispatch + +class LockFreeSingleConsumerStack { + struct Node { + let value: Element + var next: UnsafeMutablePointer? + } + typealias NodePtr = UnsafeMutablePointer + + private var _last = UnsafeAtomic.create(nil) + private var _consumerCount = UnsafeAtomic.create(0) + private var foo = 0 + + deinit { + // Discard remaining nodes + while let _ = pop() {} + _last.destroy() + _consumerCount.destroy() + } + + // Push the given element to the top of the stack. + // It is okay to concurrently call this in an arbitrary number of threads. + func push(_ value: Element) { + let new = NodePtr.allocate(capacity: 1) + new.initialize(to: Node(value: value, next: nil)) + + var done = false + var current = _last.load(ordering: .relaxed) + while !done { + new.pointee.next = current + (done, current) = _last.compareExchange( + expected: current, + desired: new, + ordering: .releasing) + } + } + + // Pop and return the topmost element from the stack. + // This method does not support multiple overlapping concurrent calls. + func pop() -> Element? { + precondition( + _consumerCount.loadThenWrappingIncrement(ordering: .acquiring) == 0, + "Multiple consumers detected") + defer { _consumerCount.wrappingDecrement(ordering: .releasing) } + var done = false + var current = _last.load(ordering: .acquiring) + while let c = current { + (done, current) = _last.compareExchange( + expected: c, + desired: c.pointee.next, + ordering: .acquiring) + if done { + let result = c.move() + c.deallocate() + return result.value + } + } + return nil + } +} + +class LockFreeSingleConsumerStackTests: XCTestCase { + func test_Basics() { + let stack = LockFreeSingleConsumerStack() + XCTAssertNil(stack.pop()) + stack.push(0) + XCTAssertEqual(0, stack.pop()) + + stack.push(1) + stack.push(2) + stack.push(3) + stack.push(4) + XCTAssertEqual(4, stack.pop()) + XCTAssertEqual(3, stack.pop()) + XCTAssertEqual(2, stack.pop()) + XCTAssertEqual(1, stack.pop()) + XCTAssertNil(stack.pop()) + } + + func test_ConcurrentPushes() { + let stack = LockFreeSingleConsumerStack<(thread: Int, value: Int)>() + + let numThreads = 100 + let numValues = 10_000 + DispatchQueue.concurrentPerform(iterations: numThreads) { thread in + for value in 1 ... numValues { + stack.push((thread: thread, value: value)) + } + } + + var expected: [Int] = Array(repeating: numValues, count: numThreads) + while let (thread, value) = stack.pop() { + XCTAssertEqual(expected[thread], value) + expected[thread] -= 1 + } + XCTAssertEqual(Array(repeating: 0, count: numThreads), expected) + } + + func test_ConcurrentPushesAndPops() { + let stack = LockFreeSingleConsumerStack<(thread: Int, value: Int)>() + + let numThreads = 100 + let numValues = 10_000 + + var perThreadSums: [Int] = Array(repeating: 0, count: numThreads) + let consumerQueue = DispatchQueue(label: "org.swift.background") + consumerQueue.async { + var count = 0 + while count < numThreads * numValues { + // Note: busy wait + if let (thread, value) = stack.pop() { + perThreadSums[thread] += value + count += 1 + } + } + } + + DispatchQueue.concurrentPerform(iterations: numThreads + 1) { thread in + if thread < numThreads { + // Producers + for value in 0 ..< numValues { + stack.push((thread: thread, value: value)) + } + } + } + + consumerQueue.sync { + XCTAssertEqual(Array(repeating: numValues * (numValues - 1) / 2, count: numThreads), perThreadSums) + } + } +} diff --git a/Tests/AtomicsTests/StrongReferenceRace.swift b/Tests/AtomicsTests/StrongReferenceRace.swift new file mode 100644 index 0000000..79ad6db --- /dev/null +++ b/Tests/AtomicsTests/StrongReferenceRace.swift @@ -0,0 +1,229 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 XCTest +import Atomics +import Dispatch + +let iterations = 1_000_000 + +private class Node: AtomicReference { + let value: Int + + init(_ value: Int = 0) { + self.value = value + Node.instances.wrappingIncrement(ordering: .relaxed) + } + deinit { + precondition(Node.instances.load(ordering: .relaxed) > 0) + Node.instances.wrappingDecrement(ordering: .relaxed) + } + + static let instances = ManagedAtomic(0) +} + +extension Node: CustomStringConvertible { + var description: String { + let unmanaged = Unmanaged.passRetained(self) + defer { unmanaged.release() } + return String(UInt(bitPattern: unmanaged.toOpaque()), radix: 16) + } +} + +@inline(never) +public func blackHole(_ value: AnyObject) {} +@inline(never) +public func blackHole(_ value: AnyObject?) {} + +class StrongReferenceRace: XCTestCase { + override func tearDown() { + super.tearDown() + let leftover = Node.instances.load(ordering: .relaxed) + XCTAssertEqual( + leftover, 0, + "Leak - \(leftover) leftover instances remaining") + } + + func checkLoad(count: Int, iterations: Int, file: StaticString = #file, line: UInt = #line) { + let ref = UnsafeAtomic.create(Node()) + defer { ref.destroy() } + + DispatchQueue.concurrentPerform(iterations: count) { id in + for _ in 0 ..< iterations { + blackHole(ref.load(ordering: .relaxed)) + } + } + } + func testLoad1() { checkLoad(count: 1, iterations: iterations) } + func testLoad2() { checkLoad(count: 2, iterations: iterations) } + func testLoad4() { checkLoad(count: 4, iterations: iterations) } + func testLoad8() { checkLoad(count: 8, iterations: iterations) } + func testLoad16() { checkLoad(count: 16, iterations: iterations) } + + func checkCompareExchange(count: Int, iterations: Int, file: StaticString = #file, line: UInt = #line) { + let a = Node() + let b = Node() + let ref = UnsafeAtomic.create(a) + defer { ref.destroy() } + + DispatchQueue.concurrentPerform(iterations: count) { id in + var expected = a + for _ in 0 ..< iterations { + var done = false + repeat { + (done, expected) = ref.compareExchange( + expected: expected, + desired: expected === a ? b : a, + ordering: .relaxed) + } while !done + } + } + } + func testCompareExchange1() { checkCompareExchange(count: 1, iterations: iterations) } + func testCompareExchange2() { checkCompareExchange(count: 2, iterations: iterations) } + func testCompareExchange4() { checkCompareExchange(count: 4, iterations: iterations) } + func testCompareExchange8() { checkCompareExchange(count: 8, iterations: iterations) } + func testCompareExchange16() { checkCompareExchange(count: 16, iterations: iterations) } + + func checkCompareExchangeNil(count: Int, iterations: Int, file: StaticString = #file, line: UInt = #line) { + let a = Node() + let b = Node() + let ref = UnsafeAtomic.create(nil) + defer { ref.destroy() } + + DispatchQueue.concurrentPerform(iterations: count) { id in + var expected: Node? = nil + for _ in 0 ..< iterations { + var done = false + repeat { + (done, expected) = ref.compareExchange( + expected: expected, + desired: expected == nil ? a : expected === a ? b : nil, + ordering: .relaxed) + } while !done + } + } + } + func testCompareExchangeNil_01() { checkCompareExchangeNil(count: 1, iterations: iterations) } + func testCompareExchangeNil_02() { checkCompareExchangeNil(count: 2, iterations: iterations) } + func testCompareExchangeNil_04() { checkCompareExchangeNil(count: 4, iterations: iterations) } + func testCompareExchangeNil_08() { checkCompareExchangeNil(count: 8, iterations: iterations) } + func testCompareExchangeNil_16() { checkCompareExchangeNil(count: 16, iterations: iterations) } + + func checkLoadStore(readers: Int, writers: Int, iterations: Int, file: StaticString = #file, line: UInt = #line) { + let a = Node() + let b = Node() + let ref = UnsafeAtomic.create(a) + defer { ref.destroy() } + + DispatchQueue.concurrentPerform(iterations: readers + writers) { id in + if id < writers { + var next = b + for _ in 0 ..< iterations { + ref.store(next, ordering: .relaxed) + next = next === a ? b : a + } + } else { + for _ in 0 ..< iterations { + blackHole(ref.load(ordering: .relaxed)) + } + } + } + } + func testLoadStore_01_01() { checkLoadStore(readers: 1, writers: 1, iterations: iterations) } + func testLoadStore_02_01() { checkLoadStore(readers: 2, writers: 1, iterations: iterations) } + func testLoadStore_04_01() { checkLoadStore(readers: 4, writers: 1, iterations: iterations) } + func testLoadStore_08_01() { checkLoadStore(readers: 8, writers: 1, iterations: iterations) } + func testLoadStore_16_01() { checkLoadStore(readers: 16, writers: 1, iterations: iterations) } + + func testLoadStore_01_02() { checkLoadStore(readers: 1, writers: 2, iterations: iterations) } + func testLoadStore_02_02() { checkLoadStore(readers: 2, writers: 2, iterations: iterations) } + func testLoadStore_04_02() { checkLoadStore(readers: 4, writers: 2, iterations: iterations) } + func testLoadStore_08_02() { checkLoadStore(readers: 8, writers: 2, iterations: iterations) } + func testLoadStore_16_02() { checkLoadStore(readers: 16, writers: 2, iterations: iterations) } + + func testLoadStore_01_04() { checkLoadStore(readers: 1, writers: 4, iterations: iterations) } + func testLoadStore_02_04() { checkLoadStore(readers: 2, writers: 4, iterations: iterations) } + func testLoadStore_04_04() { checkLoadStore(readers: 4, writers: 4, iterations: iterations) } + func testLoadStore_08_04() { checkLoadStore(readers: 8, writers: 4, iterations: iterations) } + func testLoadStore_16_04() { checkLoadStore(readers: 16, writers: 4, iterations: iterations) } + + func checkExchange(readers: Int, writers: Int, iterations: Int, file: StaticString = #file, line: UInt = #line) { + let a = Node() + let b = Node() + let ref = UnsafeAtomic.create(nil) + defer { ref.destroy() } + + DispatchQueue.concurrentPerform(iterations: readers + writers) { id in + if id < writers { + var next: Node? = nil + for _ in 0 ..< iterations { + let old = ref.exchange(next, ordering: .relaxed) + if old == nil { next = a } + else if old === a { next = b } + else { next = nil } + } + } else { + for _ in 0 ..< iterations { + blackHole(ref.load(ordering: .relaxed)) + } + } + } + } + func testExchange_01_01() { checkExchange(readers: 1, writers: 1, iterations: iterations) } + func testExchange_02_01() { checkExchange(readers: 2, writers: 1, iterations: iterations) } + func testExchange_04_01() { checkExchange(readers: 4, writers: 1, iterations: iterations) } + func testExchange_08_01() { checkExchange(readers: 8, writers: 1, iterations: iterations) } + func testExchange_16_01() { checkExchange(readers: 16, writers: 1, iterations: iterations) } + + func testExchange_01_02() { checkExchange(readers: 1, writers: 2, iterations: iterations) } + func testExchange_02_02() { checkExchange(readers: 2, writers: 2, iterations: iterations) } + func testExchange_04_02() { checkExchange(readers: 4, writers: 2, iterations: iterations) } + func testExchange_08_02() { checkExchange(readers: 8, writers: 2, iterations: iterations) } + func testExchange_16_02() { checkExchange(readers: 16, writers: 2, iterations: iterations) } + + func testExchange_01_04() { checkExchange(readers: 1, writers: 4, iterations: iterations) } + func testExchange_02_04() { checkExchange(readers: 2, writers: 4, iterations: iterations) } + func testExchange_04_04() { checkExchange(readers: 4, writers: 4, iterations: iterations) } + func testExchange_08_04() { checkExchange(readers: 8, writers: 4, iterations: iterations) } + func testExchange_16_04() { checkExchange(readers: 16, writers: 4, iterations: iterations) } + + func checkLifetimes(count: Int, iterations: Int, file: StaticString = #file, line: UInt = #line) { + precondition(count > 1) + let objects = (0 ..< count).map { ManagedAtomic(Node($0)) } + let originals = objects.map { $0.load(ordering: .relaxed).value } + + DispatchQueue.concurrentPerform(iterations: count) { id in + var object = objects[id].load(ordering: .acquiring) + var i = id + for _ in 0 ..< iterations { + let j = (i + 1) % count + object = objects[j].exchange(object, ordering: .acquiringAndReleasing) + object = objects[i].exchange(object, ordering: .acquiringAndReleasing) + i = j + } + while true { + let new = objects[object.value].exchange(object, ordering: .acquiringAndReleasing) + if new === object { break } + object = new + } + } + + let reordered = objects.map { $0.load(ordering: .relaxed).value } + print(originals, reordered) + XCTAssertEqual(Set(originals), Set(reordered)) + } + func testLifetimes_02() { checkLifetimes(count: 2, iterations: iterations) } + func testLifetimes_04() { checkLifetimes(count: 4, iterations: iterations) } + func testLifetimes_08() { checkLifetimes(count: 8, iterations: iterations) } + func testLifetimes_16() { checkLifetimes(count: 16, iterations: iterations) } +} diff --git a/Tests/AtomicsTests/StrongReferenceShuffle.swift b/Tests/AtomicsTests/StrongReferenceShuffle.swift new file mode 100644 index 0000000..1d14739 --- /dev/null +++ b/Tests/AtomicsTests/StrongReferenceShuffle.swift @@ -0,0 +1,258 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// + +// A lock-free linked list concurrency test. `n` threads are each +// racing on a linked list containing `n` values; in each iteration, +// each thread unlinks its corresponding value then reinserts it at +// the end of the list. + +import XCTest +import Atomics +import Dispatch + +let nodeCount = ManagedAtomic(0) + +private class List { + class Node: AtomicReference { + private let _next: UnsafeAtomic + private let _value: UnsafeAtomic?> + + init(pointer: UnsafeMutablePointer?, next: Node? = nil) { + self._next = .create(next) + self._value = .create(pointer) + nodeCount.wrappingIncrement(ordering: .relaxed) + } + + convenience init(_ value: Value?, next: Node? = nil) { + if let value = value { + let p = UnsafeMutablePointer.allocate(capacity: 1) + p.initialize(to: value) + self.init(pointer: p, next: next) + } else { + self.init(pointer: nil, next: next) + } + } + + deinit { + // Prevent stack overflow when deinitializing a long chain + var node = self._next.destroy() + while node != nil && isKnownUniquelyReferenced(&node) { + let next = node!._next.exchange(nil, ordering: .relaxed) + withExtendedLifetime(node) {} + node = next + } + + if let p = self._value.destroy() { + p.deinitialize(count: 1) + p.deallocate() + } + nodeCount.wrappingDecrement(ordering: .relaxed) + } + + var value: Value? { _value.load(ordering: .sequentiallyConsistent)?.pointee } + + func clearValue() -> UnsafeMutablePointer? { + withExtendedLifetime(self) { + _value.exchange(nil, ordering: .sequentiallyConsistent) + } + } + + var next: Node? { _next.load(ordering: .sequentiallyConsistent) } + + func clearNext() -> Node? { + withExtendedLifetime(self) { + _next.exchange(nil, ordering: .sequentiallyConsistent) + } + } + + func compareExchangeNext(expected: Node?, desired: Node?) -> (exchanged: Bool, original: Node?) { + withExtendedLifetime(self) { + _next.compareExchange(expected: expected, desired: desired, ordering: .sequentiallyConsistent) + } + } + } + + let head: Node + + init(from elements: Elements) + where Elements.Element == Value { + var n: Node? = nil + for value in elements.reversed() { + n = Node(value, next: n) + } + self.head = Node(nil, next: n) + } + + deinit { + // Prevent a stack overflow while recursively releasing list nodes. + var node = head.clearNext() + while let n = node { + let next = n.clearNext() + node = next + } + } +} + +extension List { + /// Move the given value to the end of this list. It is safe to call + /// this concurrently on multiple threads as long as all invocations + /// are using distinct values. + func sink(_ value: Value) { + var current = self.head + var next = self.head.next + var anchor = current + var anchorNext = next + var found = false + + var new: Node? + while true { + if let n = next { + var v = n.value + if !found, v == value { + // Mark this node as deleted. + found = true + new = Node(pointer: n.clearValue(), next: nil) + precondition(new?.value == value, "Concurrent sink invocations with the same value") + v = nil + } + current = n + next = n.next + if v != nil { + if current !== anchor { + // Opportunistically unlink the chain of deleted nodes between `anchor` and `n`. + _ = anchor.compareExchangeNext(expected: anchorNext, desired: n) + } + anchor = current + anchorNext = next + } + } else { + // `next` is nil. Append `new` to the end of the list. + precondition(found, "Lost value \(value) in \(read())") + let (exchanged, original) = current.compareExchangeNext(expected: nil, desired: new) + if exchanged { + if current !== anchor { + // Opportunistically unlink the chain of deleted nodes between `anchor` and `new`. + _ = anchor.compareExchangeNext(expected: anchorNext, desired: new) + } + return + } + next = original + } + } + } + + /// Read out and return the contents of this list in an array. Note + /// that this may return duplicate or missing elements if it is + /// called concurrently with `sink`. (This is still safe -- the + /// results may be useless, but the returned values are still + /// valid.) + @inline(never) + func read() -> [Value?] { + var result: [Value?] = [] + var node = head + while let next = node.next { + result.append(next.value) + node = next + } + withExtendedLifetime(node) {} + return result + } + + @inline(never) + func readUnique(expectedCount: Int = 0) -> Set where Value: Hashable { + var result: Set = [] + result.reserveCapacity(expectedCount) + var node = head + while let next = node.next { + if let value = next.value { + result.insert(value) + } + node = next + } + withExtendedLifetime(node) {} + return result + } +} + + +class StrongReferenceShuffleTests: XCTestCase { + override func tearDown() { + XCTAssertEqual(nodeCount.load(ordering: .relaxed), 0) + } + + func checkSink( + writers: Int, + readers: Int, + iterations: Int, + file: StaticString = #file, + line: UInt = #line + ) { + let list = List(from: 0 ..< writers) + + XCTAssertEqual(list.read(), Array(0 ..< writers), + "Unexpected list contents at start", + file: file, line: line) + + DispatchQueue.concurrentPerform(iterations: readers + writers) { id in + if id < writers { + for _ in 0 ..< iterations { + list.sink(id) + } + } else { + for _ in 0 ..< iterations { + let elements = list.readUnique(expectedCount: writers) + precondition(elements.count <= writers) + } + } + } + + let contents = list.read() + print( + contents + .map { value -> String in + if let value = value { return "\(value)" } + return "nil" + } + .joined(separator: ", ")) + let values = Set(contents.compactMap { $0 }) + XCTAssertEqual(values, Set(0 ..< writers), + "Unexpected list contents at end", + file: file, line: line) + } + + private let iterations = 1_000_000 + + func test_sink_01_00() { checkSink(writers: 1, readers: 0, iterations: iterations) } + func test_sink_02_00() { checkSink(writers: 2, readers: 0, iterations: iterations) } + func test_sink_04_00() { checkSink(writers: 4, readers: 0, iterations: iterations) } + func test_sink_08_00() { checkSink(writers: 8, readers: 0, iterations: iterations) } + + func test_sink_01_01() { checkSink(writers: 1, readers: 1, iterations: iterations) } + func test_sink_02_01() { checkSink(writers: 2, readers: 1, iterations: iterations) } + func test_sink_04_01() { checkSink(writers: 4, readers: 1, iterations: iterations) } + func test_sink_08_01() { checkSink(writers: 8, readers: 1, iterations: iterations) } + + func test_sink_01_02() { checkSink(writers: 1, readers: 2, iterations: iterations) } + func test_sink_02_02() { checkSink(writers: 2, readers: 2, iterations: iterations) } + func test_sink_04_02() { checkSink(writers: 4, readers: 2, iterations: iterations) } + func test_sink_08_02() { checkSink(writers: 8, readers: 2, iterations: iterations) } + + func test_sink_01_04() { checkSink(writers: 1, readers: 4, iterations: iterations) } + func test_sink_02_04() { checkSink(writers: 2, readers: 4, iterations: iterations) } + func test_sink_04_04() { checkSink(writers: 4, readers: 4, iterations: iterations) } + func test_sink_08_04() { checkSink(writers: 8, readers: 4, iterations: iterations) } + + func test_sink_01_08() { checkSink(writers: 1, readers: 8, iterations: iterations) } + func test_sink_02_08() { checkSink(writers: 2, readers: 8, iterations: iterations) } + func test_sink_04_08() { checkSink(writers: 4, readers: 8, iterations: iterations) } + func test_sink_08_08() { checkSink(writers: 8, readers: 8, iterations: iterations) } +} diff --git a/Tests/AtomicsTests/UnsafeAtomicLazyReference.swift b/Tests/AtomicsTests/UnsafeAtomicLazyReference.swift new file mode 100644 index 0000000..dcbed0e --- /dev/null +++ b/Tests/AtomicsTests/UnsafeAtomicLazyReference.swift @@ -0,0 +1,40 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 XCTest +import Atomics + +class UnsafeAtomicLazyReferenceTests: XCTestCase { + func test_create_destroy() { + let v = UnsafeAtomicLazyReference.create() + defer { v.destroy() } + XCTAssertNil(v.load()) + } + + func test_storeIfNilThenLoad() { + do { + let v = UnsafeAtomicLazyReference.create() + XCTAssertNil(v.load()) + + let ref = LifetimeTracked(42) + XCTAssertTrue(v.storeIfNilThenLoad(ref) === ref) + XCTAssertTrue(v.load() === ref) + + let ref2 = LifetimeTracked(23) + XCTAssertTrue(v.storeIfNilThenLoad(ref2) === ref) + XCTAssertTrue(v.load() === ref) + + v.destroy() + } + XCTAssertEqual(LifetimeTracked.instances, 0) + } +} diff --git a/Tests/AtomicsTests/XCTestManifests.swift b/Tests/AtomicsTests/XCTestManifests.swift new file mode 100644 index 0000000..a5d5092 --- /dev/null +++ b/Tests/AtomicsTests/XCTestManifests.swift @@ -0,0 +1,1738 @@ +#if !canImport(ObjectiveC) +import XCTest + +extension BasicAtomicTests { + // DO NOT MODIFY: This is autogenerated, use: + // `swift test --generate-linuxmain` + // to regenerate. + static let __allTests__BasicAtomicTests = [ + ("test_Bool_compareExchange_acquiring", test_Bool_compareExchange_acquiring), + ("test_Bool_compareExchange_acquiring_acquiring", test_Bool_compareExchange_acquiring_acquiring), + ("test_Bool_compareExchange_acquiring_relaxed", test_Bool_compareExchange_acquiring_relaxed), + ("test_Bool_compareExchange_acquiring_sequentiallyConsistent", test_Bool_compareExchange_acquiring_sequentiallyConsistent), + ("test_Bool_compareExchange_acquiringAndReleasing", test_Bool_compareExchange_acquiringAndReleasing), + ("test_Bool_compareExchange_acquiringAndReleasing_acquiring", test_Bool_compareExchange_acquiringAndReleasing_acquiring), + ("test_Bool_compareExchange_acquiringAndReleasing_relaxed", test_Bool_compareExchange_acquiringAndReleasing_relaxed), + ("test_Bool_compareExchange_acquiringAndReleasing_sequentiallyConsistent", test_Bool_compareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_Bool_compareExchange_relaxed", test_Bool_compareExchange_relaxed), + ("test_Bool_compareExchange_relaxed_acquiring", test_Bool_compareExchange_relaxed_acquiring), + ("test_Bool_compareExchange_relaxed_relaxed", test_Bool_compareExchange_relaxed_relaxed), + ("test_Bool_compareExchange_relaxed_sequentiallyConsistent", test_Bool_compareExchange_relaxed_sequentiallyConsistent), + ("test_Bool_compareExchange_releasing", test_Bool_compareExchange_releasing), + ("test_Bool_compareExchange_releasing_acquiring", test_Bool_compareExchange_releasing_acquiring), + ("test_Bool_compareExchange_releasing_relaxed", test_Bool_compareExchange_releasing_relaxed), + ("test_Bool_compareExchange_releasing_sequentiallyConsistent", test_Bool_compareExchange_releasing_sequentiallyConsistent), + ("test_Bool_compareExchange_sequentiallyConsistent", test_Bool_compareExchange_sequentiallyConsistent), + ("test_Bool_compareExchange_sequentiallyConsistent_acquiring", test_Bool_compareExchange_sequentiallyConsistent_acquiring), + ("test_Bool_compareExchange_sequentiallyConsistent_relaxed", test_Bool_compareExchange_sequentiallyConsistent_relaxed), + ("test_Bool_compareExchange_sequentiallyConsistent_sequentiallyConsistent", test_Bool_compareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_Bool_create_destroy", test_Bool_create_destroy), + ("test_Bool_exchange_acquiring", test_Bool_exchange_acquiring), + ("test_Bool_exchange_acquiringAndReleasing", test_Bool_exchange_acquiringAndReleasing), + ("test_Bool_exchange_relaxed", test_Bool_exchange_relaxed), + ("test_Bool_exchange_releasing", test_Bool_exchange_releasing), + ("test_Bool_exchange_sequentiallyConsistent", test_Bool_exchange_sequentiallyConsistent), + ("test_Bool_load_acquiring", test_Bool_load_acquiring), + ("test_Bool_load_relaxed", test_Bool_load_relaxed), + ("test_Bool_load_sequentiallyConsistent", test_Bool_load_sequentiallyConsistent), + ("test_Bool_loadThenLogicalAnd_acquiring", test_Bool_loadThenLogicalAnd_acquiring), + ("test_Bool_loadThenLogicalAnd_acquiringAndReleasing", test_Bool_loadThenLogicalAnd_acquiringAndReleasing), + ("test_Bool_loadThenLogicalAnd_relaxed", test_Bool_loadThenLogicalAnd_relaxed), + ("test_Bool_loadThenLogicalAnd_releasing", test_Bool_loadThenLogicalAnd_releasing), + ("test_Bool_loadThenLogicalAnd_sequentiallyConsistent", test_Bool_loadThenLogicalAnd_sequentiallyConsistent), + ("test_Bool_loadThenLogicalOr_acquiring", test_Bool_loadThenLogicalOr_acquiring), + ("test_Bool_loadThenLogicalOr_acquiringAndReleasing", test_Bool_loadThenLogicalOr_acquiringAndReleasing), + ("test_Bool_loadThenLogicalOr_relaxed", test_Bool_loadThenLogicalOr_relaxed), + ("test_Bool_loadThenLogicalOr_releasing", test_Bool_loadThenLogicalOr_releasing), + ("test_Bool_loadThenLogicalOr_sequentiallyConsistent", test_Bool_loadThenLogicalOr_sequentiallyConsistent), + ("test_Bool_loadThenLogicalXor_acquiring", test_Bool_loadThenLogicalXor_acquiring), + ("test_Bool_loadThenLogicalXor_acquiringAndReleasing", test_Bool_loadThenLogicalXor_acquiringAndReleasing), + ("test_Bool_loadThenLogicalXor_relaxed", test_Bool_loadThenLogicalXor_relaxed), + ("test_Bool_loadThenLogicalXor_releasing", test_Bool_loadThenLogicalXor_releasing), + ("test_Bool_loadThenLogicalXor_sequentiallyConsistent", test_Bool_loadThenLogicalXor_sequentiallyConsistent), + ("test_Bool_logicalAndThenLoad_acquiring", test_Bool_logicalAndThenLoad_acquiring), + ("test_Bool_logicalAndThenLoad_acquiringAndReleasing", test_Bool_logicalAndThenLoad_acquiringAndReleasing), + ("test_Bool_logicalAndThenLoad_relaxed", test_Bool_logicalAndThenLoad_relaxed), + ("test_Bool_logicalAndThenLoad_releasing", test_Bool_logicalAndThenLoad_releasing), + ("test_Bool_logicalAndThenLoad_sequentiallyConsistent", test_Bool_logicalAndThenLoad_sequentiallyConsistent), + ("test_Bool_logicalOrThenLoad_acquiring", test_Bool_logicalOrThenLoad_acquiring), + ("test_Bool_logicalOrThenLoad_acquiringAndReleasing", test_Bool_logicalOrThenLoad_acquiringAndReleasing), + ("test_Bool_logicalOrThenLoad_relaxed", test_Bool_logicalOrThenLoad_relaxed), + ("test_Bool_logicalOrThenLoad_releasing", test_Bool_logicalOrThenLoad_releasing), + ("test_Bool_logicalOrThenLoad_sequentiallyConsistent", test_Bool_logicalOrThenLoad_sequentiallyConsistent), + ("test_Bool_logicalXorThenLoad_acquiring", test_Bool_logicalXorThenLoad_acquiring), + ("test_Bool_logicalXorThenLoad_acquiringAndReleasing", test_Bool_logicalXorThenLoad_acquiringAndReleasing), + ("test_Bool_logicalXorThenLoad_relaxed", test_Bool_logicalXorThenLoad_relaxed), + ("test_Bool_logicalXorThenLoad_releasing", test_Bool_logicalXorThenLoad_releasing), + ("test_Bool_logicalXorThenLoad_sequentiallyConsistent", test_Bool_logicalXorThenLoad_sequentiallyConsistent), + ("test_Bool_store_relaxed", test_Bool_store_relaxed), + ("test_Bool_store_releasing", test_Bool_store_releasing), + ("test_Bool_store_sequentiallyConsistent", test_Bool_store_sequentiallyConsistent), + ("test_Bool_weakCompareExchange_acquiring_acquiring", test_Bool_weakCompareExchange_acquiring_acquiring), + ("test_Bool_weakCompareExchange_acquiring_relaxed", test_Bool_weakCompareExchange_acquiring_relaxed), + ("test_Bool_weakCompareExchange_acquiring_sequentiallyConsistent", test_Bool_weakCompareExchange_acquiring_sequentiallyConsistent), + ("test_Bool_weakCompareExchange_acquiringAndReleasing_acquiring", test_Bool_weakCompareExchange_acquiringAndReleasing_acquiring), + ("test_Bool_weakCompareExchange_acquiringAndReleasing_relaxed", test_Bool_weakCompareExchange_acquiringAndReleasing_relaxed), + ("test_Bool_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent", test_Bool_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_Bool_weakCompareExchange_relaxed_acquiring", test_Bool_weakCompareExchange_relaxed_acquiring), + ("test_Bool_weakCompareExchange_relaxed_relaxed", test_Bool_weakCompareExchange_relaxed_relaxed), + ("test_Bool_weakCompareExchange_relaxed_sequentiallyConsistent", test_Bool_weakCompareExchange_relaxed_sequentiallyConsistent), + ("test_Bool_weakCompareExchange_releasing_acquiring", test_Bool_weakCompareExchange_releasing_acquiring), + ("test_Bool_weakCompareExchange_releasing_relaxed", test_Bool_weakCompareExchange_releasing_relaxed), + ("test_Bool_weakCompareExchange_releasing_sequentiallyConsistent", test_Bool_weakCompareExchange_releasing_sequentiallyConsistent), + ("test_Bool_weakCompareExchange_sequentiallyConsistent_acquiring", test_Bool_weakCompareExchange_sequentiallyConsistent_acquiring), + ("test_Bool_weakCompareExchange_sequentiallyConsistent_relaxed", test_Bool_weakCompareExchange_sequentiallyConsistent_relaxed), + ("test_Bool_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent", test_Bool_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_DoubleWord_compareExchange_acquiring", test_DoubleWord_compareExchange_acquiring), + ("test_DoubleWord_compareExchange_acquiring_acquiring", test_DoubleWord_compareExchange_acquiring_acquiring), + ("test_DoubleWord_compareExchange_acquiring_relaxed", test_DoubleWord_compareExchange_acquiring_relaxed), + ("test_DoubleWord_compareExchange_acquiring_sequentiallyConsistent", test_DoubleWord_compareExchange_acquiring_sequentiallyConsistent), + ("test_DoubleWord_compareExchange_acquiringAndReleasing", test_DoubleWord_compareExchange_acquiringAndReleasing), + ("test_DoubleWord_compareExchange_acquiringAndReleasing_acquiring", test_DoubleWord_compareExchange_acquiringAndReleasing_acquiring), + ("test_DoubleWord_compareExchange_acquiringAndReleasing_relaxed", test_DoubleWord_compareExchange_acquiringAndReleasing_relaxed), + ("test_DoubleWord_compareExchange_acquiringAndReleasing_sequentiallyConsistent", test_DoubleWord_compareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_DoubleWord_compareExchange_relaxed", test_DoubleWord_compareExchange_relaxed), + ("test_DoubleWord_compareExchange_relaxed_acquiring", test_DoubleWord_compareExchange_relaxed_acquiring), + ("test_DoubleWord_compareExchange_relaxed_relaxed", test_DoubleWord_compareExchange_relaxed_relaxed), + ("test_DoubleWord_compareExchange_relaxed_sequentiallyConsistent", test_DoubleWord_compareExchange_relaxed_sequentiallyConsistent), + ("test_DoubleWord_compareExchange_releasing", test_DoubleWord_compareExchange_releasing), + ("test_DoubleWord_compareExchange_releasing_acquiring", test_DoubleWord_compareExchange_releasing_acquiring), + ("test_DoubleWord_compareExchange_releasing_relaxed", test_DoubleWord_compareExchange_releasing_relaxed), + ("test_DoubleWord_compareExchange_releasing_sequentiallyConsistent", test_DoubleWord_compareExchange_releasing_sequentiallyConsistent), + ("test_DoubleWord_compareExchange_sequentiallyConsistent", test_DoubleWord_compareExchange_sequentiallyConsistent), + ("test_DoubleWord_compareExchange_sequentiallyConsistent_acquiring", test_DoubleWord_compareExchange_sequentiallyConsistent_acquiring), + ("test_DoubleWord_compareExchange_sequentiallyConsistent_relaxed", test_DoubleWord_compareExchange_sequentiallyConsistent_relaxed), + ("test_DoubleWord_compareExchange_sequentiallyConsistent_sequentiallyConsistent", test_DoubleWord_compareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_DoubleWord_create_destroy", test_DoubleWord_create_destroy), + ("test_DoubleWord_exchange_acquiring", test_DoubleWord_exchange_acquiring), + ("test_DoubleWord_exchange_acquiringAndReleasing", test_DoubleWord_exchange_acquiringAndReleasing), + ("test_DoubleWord_exchange_relaxed", test_DoubleWord_exchange_relaxed), + ("test_DoubleWord_exchange_releasing", test_DoubleWord_exchange_releasing), + ("test_DoubleWord_exchange_sequentiallyConsistent", test_DoubleWord_exchange_sequentiallyConsistent), + ("test_DoubleWord_load_acquiring", test_DoubleWord_load_acquiring), + ("test_DoubleWord_load_relaxed", test_DoubleWord_load_relaxed), + ("test_DoubleWord_load_sequentiallyConsistent", test_DoubleWord_load_sequentiallyConsistent), + ("test_DoubleWord_store_relaxed", test_DoubleWord_store_relaxed), + ("test_DoubleWord_store_releasing", test_DoubleWord_store_releasing), + ("test_DoubleWord_store_sequentiallyConsistent", test_DoubleWord_store_sequentiallyConsistent), + ("test_DoubleWord_weakCompareExchange_acquiring_acquiring", test_DoubleWord_weakCompareExchange_acquiring_acquiring), + ("test_DoubleWord_weakCompareExchange_acquiring_relaxed", test_DoubleWord_weakCompareExchange_acquiring_relaxed), + ("test_DoubleWord_weakCompareExchange_acquiring_sequentiallyConsistent", test_DoubleWord_weakCompareExchange_acquiring_sequentiallyConsistent), + ("test_DoubleWord_weakCompareExchange_acquiringAndReleasing_acquiring", test_DoubleWord_weakCompareExchange_acquiringAndReleasing_acquiring), + ("test_DoubleWord_weakCompareExchange_acquiringAndReleasing_relaxed", test_DoubleWord_weakCompareExchange_acquiringAndReleasing_relaxed), + ("test_DoubleWord_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent", test_DoubleWord_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_DoubleWord_weakCompareExchange_relaxed_acquiring", test_DoubleWord_weakCompareExchange_relaxed_acquiring), + ("test_DoubleWord_weakCompareExchange_relaxed_relaxed", test_DoubleWord_weakCompareExchange_relaxed_relaxed), + ("test_DoubleWord_weakCompareExchange_relaxed_sequentiallyConsistent", test_DoubleWord_weakCompareExchange_relaxed_sequentiallyConsistent), + ("test_DoubleWord_weakCompareExchange_releasing_acquiring", test_DoubleWord_weakCompareExchange_releasing_acquiring), + ("test_DoubleWord_weakCompareExchange_releasing_relaxed", test_DoubleWord_weakCompareExchange_releasing_relaxed), + ("test_DoubleWord_weakCompareExchange_releasing_sequentiallyConsistent", test_DoubleWord_weakCompareExchange_releasing_sequentiallyConsistent), + ("test_DoubleWord_weakCompareExchange_sequentiallyConsistent_acquiring", test_DoubleWord_weakCompareExchange_sequentiallyConsistent_acquiring), + ("test_DoubleWord_weakCompareExchange_sequentiallyConsistent_relaxed", test_DoubleWord_weakCompareExchange_sequentiallyConsistent_relaxed), + ("test_DoubleWord_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent", test_DoubleWord_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_Int16_bitwiseAndThenLoad_acquiring", test_Int16_bitwiseAndThenLoad_acquiring), + ("test_Int16_bitwiseAndThenLoad_acquiringAndReleasing", test_Int16_bitwiseAndThenLoad_acquiringAndReleasing), + ("test_Int16_bitwiseAndThenLoad_relaxed", test_Int16_bitwiseAndThenLoad_relaxed), + ("test_Int16_bitwiseAndThenLoad_releasing", test_Int16_bitwiseAndThenLoad_releasing), + ("test_Int16_bitwiseAndThenLoad_sequentiallyConsistent", test_Int16_bitwiseAndThenLoad_sequentiallyConsistent), + ("test_Int16_bitwiseOrThenLoad_acquiring", test_Int16_bitwiseOrThenLoad_acquiring), + ("test_Int16_bitwiseOrThenLoad_acquiringAndReleasing", test_Int16_bitwiseOrThenLoad_acquiringAndReleasing), + ("test_Int16_bitwiseOrThenLoad_relaxed", test_Int16_bitwiseOrThenLoad_relaxed), + ("test_Int16_bitwiseOrThenLoad_releasing", test_Int16_bitwiseOrThenLoad_releasing), + ("test_Int16_bitwiseOrThenLoad_sequentiallyConsistent", test_Int16_bitwiseOrThenLoad_sequentiallyConsistent), + ("test_Int16_bitwiseXorThenLoad_acquiring", test_Int16_bitwiseXorThenLoad_acquiring), + ("test_Int16_bitwiseXorThenLoad_acquiringAndReleasing", test_Int16_bitwiseXorThenLoad_acquiringAndReleasing), + ("test_Int16_bitwiseXorThenLoad_relaxed", test_Int16_bitwiseXorThenLoad_relaxed), + ("test_Int16_bitwiseXorThenLoad_releasing", test_Int16_bitwiseXorThenLoad_releasing), + ("test_Int16_bitwiseXorThenLoad_sequentiallyConsistent", test_Int16_bitwiseXorThenLoad_sequentiallyConsistent), + ("test_Int16_compareExchange_acquiring", test_Int16_compareExchange_acquiring), + ("test_Int16_compareExchange_acquiring_acquiring", test_Int16_compareExchange_acquiring_acquiring), + ("test_Int16_compareExchange_acquiring_relaxed", test_Int16_compareExchange_acquiring_relaxed), + ("test_Int16_compareExchange_acquiring_sequentiallyConsistent", test_Int16_compareExchange_acquiring_sequentiallyConsistent), + ("test_Int16_compareExchange_acquiringAndReleasing", test_Int16_compareExchange_acquiringAndReleasing), + ("test_Int16_compareExchange_acquiringAndReleasing_acquiring", test_Int16_compareExchange_acquiringAndReleasing_acquiring), + ("test_Int16_compareExchange_acquiringAndReleasing_relaxed", test_Int16_compareExchange_acquiringAndReleasing_relaxed), + ("test_Int16_compareExchange_acquiringAndReleasing_sequentiallyConsistent", test_Int16_compareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_Int16_compareExchange_relaxed", test_Int16_compareExchange_relaxed), + ("test_Int16_compareExchange_relaxed_acquiring", test_Int16_compareExchange_relaxed_acquiring), + ("test_Int16_compareExchange_relaxed_relaxed", test_Int16_compareExchange_relaxed_relaxed), + ("test_Int16_compareExchange_relaxed_sequentiallyConsistent", test_Int16_compareExchange_relaxed_sequentiallyConsistent), + ("test_Int16_compareExchange_releasing", test_Int16_compareExchange_releasing), + ("test_Int16_compareExchange_releasing_acquiring", test_Int16_compareExchange_releasing_acquiring), + ("test_Int16_compareExchange_releasing_relaxed", test_Int16_compareExchange_releasing_relaxed), + ("test_Int16_compareExchange_releasing_sequentiallyConsistent", test_Int16_compareExchange_releasing_sequentiallyConsistent), + ("test_Int16_compareExchange_sequentiallyConsistent", test_Int16_compareExchange_sequentiallyConsistent), + ("test_Int16_compareExchange_sequentiallyConsistent_acquiring", test_Int16_compareExchange_sequentiallyConsistent_acquiring), + ("test_Int16_compareExchange_sequentiallyConsistent_relaxed", test_Int16_compareExchange_sequentiallyConsistent_relaxed), + ("test_Int16_compareExchange_sequentiallyConsistent_sequentiallyConsistent", test_Int16_compareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_Int16_create_destroy", test_Int16_create_destroy), + ("test_Int16_exchange_acquiring", test_Int16_exchange_acquiring), + ("test_Int16_exchange_acquiringAndReleasing", test_Int16_exchange_acquiringAndReleasing), + ("test_Int16_exchange_relaxed", test_Int16_exchange_relaxed), + ("test_Int16_exchange_releasing", test_Int16_exchange_releasing), + ("test_Int16_exchange_sequentiallyConsistent", test_Int16_exchange_sequentiallyConsistent), + ("test_Int16_load_acquiring", test_Int16_load_acquiring), + ("test_Int16_load_relaxed", test_Int16_load_relaxed), + ("test_Int16_load_sequentiallyConsistent", test_Int16_load_sequentiallyConsistent), + ("test_Int16_loadThenBitwiseAnd_acquiring", test_Int16_loadThenBitwiseAnd_acquiring), + ("test_Int16_loadThenBitwiseAnd_acquiringAndReleasing", test_Int16_loadThenBitwiseAnd_acquiringAndReleasing), + ("test_Int16_loadThenBitwiseAnd_relaxed", test_Int16_loadThenBitwiseAnd_relaxed), + ("test_Int16_loadThenBitwiseAnd_releasing", test_Int16_loadThenBitwiseAnd_releasing), + ("test_Int16_loadThenBitwiseAnd_sequentiallyConsistent", test_Int16_loadThenBitwiseAnd_sequentiallyConsistent), + ("test_Int16_loadThenBitwiseOr_acquiring", test_Int16_loadThenBitwiseOr_acquiring), + ("test_Int16_loadThenBitwiseOr_acquiringAndReleasing", test_Int16_loadThenBitwiseOr_acquiringAndReleasing), + ("test_Int16_loadThenBitwiseOr_relaxed", test_Int16_loadThenBitwiseOr_relaxed), + ("test_Int16_loadThenBitwiseOr_releasing", test_Int16_loadThenBitwiseOr_releasing), + ("test_Int16_loadThenBitwiseOr_sequentiallyConsistent", test_Int16_loadThenBitwiseOr_sequentiallyConsistent), + ("test_Int16_loadThenBitwiseXor_acquiring", test_Int16_loadThenBitwiseXor_acquiring), + ("test_Int16_loadThenBitwiseXor_acquiringAndReleasing", test_Int16_loadThenBitwiseXor_acquiringAndReleasing), + ("test_Int16_loadThenBitwiseXor_relaxed", test_Int16_loadThenBitwiseXor_relaxed), + ("test_Int16_loadThenBitwiseXor_releasing", test_Int16_loadThenBitwiseXor_releasing), + ("test_Int16_loadThenBitwiseXor_sequentiallyConsistent", test_Int16_loadThenBitwiseXor_sequentiallyConsistent), + ("test_Int16_loadThenWrappingDecrement_acquiring", test_Int16_loadThenWrappingDecrement_acquiring), + ("test_Int16_loadThenWrappingDecrement_acquiringAndReleasing", test_Int16_loadThenWrappingDecrement_acquiringAndReleasing), + ("test_Int16_loadThenWrappingDecrement_relaxed", test_Int16_loadThenWrappingDecrement_relaxed), + ("test_Int16_loadThenWrappingDecrement_releasing", test_Int16_loadThenWrappingDecrement_releasing), + ("test_Int16_loadThenWrappingDecrement_sequentiallyConsistent", test_Int16_loadThenWrappingDecrement_sequentiallyConsistent), + ("test_Int16_loadThenWrappingIncrement_acquiring", test_Int16_loadThenWrappingIncrement_acquiring), + ("test_Int16_loadThenWrappingIncrement_acquiringAndReleasing", test_Int16_loadThenWrappingIncrement_acquiringAndReleasing), + ("test_Int16_loadThenWrappingIncrement_relaxed", test_Int16_loadThenWrappingIncrement_relaxed), + ("test_Int16_loadThenWrappingIncrement_releasing", test_Int16_loadThenWrappingIncrement_releasing), + ("test_Int16_loadThenWrappingIncrement_sequentiallyConsistent", test_Int16_loadThenWrappingIncrement_sequentiallyConsistent), + ("test_Int16_store_relaxed", test_Int16_store_relaxed), + ("test_Int16_store_releasing", test_Int16_store_releasing), + ("test_Int16_store_sequentiallyConsistent", test_Int16_store_sequentiallyConsistent), + ("test_Int16_weakCompareExchange_acquiring_acquiring", test_Int16_weakCompareExchange_acquiring_acquiring), + ("test_Int16_weakCompareExchange_acquiring_relaxed", test_Int16_weakCompareExchange_acquiring_relaxed), + ("test_Int16_weakCompareExchange_acquiring_sequentiallyConsistent", test_Int16_weakCompareExchange_acquiring_sequentiallyConsistent), + ("test_Int16_weakCompareExchange_acquiringAndReleasing_acquiring", test_Int16_weakCompareExchange_acquiringAndReleasing_acquiring), + ("test_Int16_weakCompareExchange_acquiringAndReleasing_relaxed", test_Int16_weakCompareExchange_acquiringAndReleasing_relaxed), + ("test_Int16_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent", test_Int16_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_Int16_weakCompareExchange_relaxed_acquiring", test_Int16_weakCompareExchange_relaxed_acquiring), + ("test_Int16_weakCompareExchange_relaxed_relaxed", test_Int16_weakCompareExchange_relaxed_relaxed), + ("test_Int16_weakCompareExchange_relaxed_sequentiallyConsistent", test_Int16_weakCompareExchange_relaxed_sequentiallyConsistent), + ("test_Int16_weakCompareExchange_releasing_acquiring", test_Int16_weakCompareExchange_releasing_acquiring), + ("test_Int16_weakCompareExchange_releasing_relaxed", test_Int16_weakCompareExchange_releasing_relaxed), + ("test_Int16_weakCompareExchange_releasing_sequentiallyConsistent", test_Int16_weakCompareExchange_releasing_sequentiallyConsistent), + ("test_Int16_weakCompareExchange_sequentiallyConsistent_acquiring", test_Int16_weakCompareExchange_sequentiallyConsistent_acquiring), + ("test_Int16_weakCompareExchange_sequentiallyConsistent_relaxed", test_Int16_weakCompareExchange_sequentiallyConsistent_relaxed), + ("test_Int16_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent", test_Int16_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_Int16_wrappingDecrementThenLoad_acquiring", test_Int16_wrappingDecrementThenLoad_acquiring), + ("test_Int16_wrappingDecrementThenLoad_acquiringAndReleasing", test_Int16_wrappingDecrementThenLoad_acquiringAndReleasing), + ("test_Int16_wrappingDecrementThenLoad_relaxed", test_Int16_wrappingDecrementThenLoad_relaxed), + ("test_Int16_wrappingDecrementThenLoad_releasing", test_Int16_wrappingDecrementThenLoad_releasing), + ("test_Int16_wrappingDecrementThenLoad_sequentiallyConsistent", test_Int16_wrappingDecrementThenLoad_sequentiallyConsistent), + ("test_Int16_wrappingIncrementThenLoad_acquiring", test_Int16_wrappingIncrementThenLoad_acquiring), + ("test_Int16_wrappingIncrementThenLoad_acquiringAndReleasing", test_Int16_wrappingIncrementThenLoad_acquiringAndReleasing), + ("test_Int16_wrappingIncrementThenLoad_relaxed", test_Int16_wrappingIncrementThenLoad_relaxed), + ("test_Int16_wrappingIncrementThenLoad_releasing", test_Int16_wrappingIncrementThenLoad_releasing), + ("test_Int16_wrappingIncrementThenLoad_sequentiallyConsistent", test_Int16_wrappingIncrementThenLoad_sequentiallyConsistent), + ("test_Int32_bitwiseAndThenLoad_acquiring", test_Int32_bitwiseAndThenLoad_acquiring), + ("test_Int32_bitwiseAndThenLoad_acquiringAndReleasing", test_Int32_bitwiseAndThenLoad_acquiringAndReleasing), + ("test_Int32_bitwiseAndThenLoad_relaxed", test_Int32_bitwiseAndThenLoad_relaxed), + ("test_Int32_bitwiseAndThenLoad_releasing", test_Int32_bitwiseAndThenLoad_releasing), + ("test_Int32_bitwiseAndThenLoad_sequentiallyConsistent", test_Int32_bitwiseAndThenLoad_sequentiallyConsistent), + ("test_Int32_bitwiseOrThenLoad_acquiring", test_Int32_bitwiseOrThenLoad_acquiring), + ("test_Int32_bitwiseOrThenLoad_acquiringAndReleasing", test_Int32_bitwiseOrThenLoad_acquiringAndReleasing), + ("test_Int32_bitwiseOrThenLoad_relaxed", test_Int32_bitwiseOrThenLoad_relaxed), + ("test_Int32_bitwiseOrThenLoad_releasing", test_Int32_bitwiseOrThenLoad_releasing), + ("test_Int32_bitwiseOrThenLoad_sequentiallyConsistent", test_Int32_bitwiseOrThenLoad_sequentiallyConsistent), + ("test_Int32_bitwiseXorThenLoad_acquiring", test_Int32_bitwiseXorThenLoad_acquiring), + ("test_Int32_bitwiseXorThenLoad_acquiringAndReleasing", test_Int32_bitwiseXorThenLoad_acquiringAndReleasing), + ("test_Int32_bitwiseXorThenLoad_relaxed", test_Int32_bitwiseXorThenLoad_relaxed), + ("test_Int32_bitwiseXorThenLoad_releasing", test_Int32_bitwiseXorThenLoad_releasing), + ("test_Int32_bitwiseXorThenLoad_sequentiallyConsistent", test_Int32_bitwiseXorThenLoad_sequentiallyConsistent), + ("test_Int32_compareExchange_acquiring", test_Int32_compareExchange_acquiring), + ("test_Int32_compareExchange_acquiring_acquiring", test_Int32_compareExchange_acquiring_acquiring), + ("test_Int32_compareExchange_acquiring_relaxed", test_Int32_compareExchange_acquiring_relaxed), + ("test_Int32_compareExchange_acquiring_sequentiallyConsistent", test_Int32_compareExchange_acquiring_sequentiallyConsistent), + ("test_Int32_compareExchange_acquiringAndReleasing", test_Int32_compareExchange_acquiringAndReleasing), + ("test_Int32_compareExchange_acquiringAndReleasing_acquiring", test_Int32_compareExchange_acquiringAndReleasing_acquiring), + ("test_Int32_compareExchange_acquiringAndReleasing_relaxed", test_Int32_compareExchange_acquiringAndReleasing_relaxed), + ("test_Int32_compareExchange_acquiringAndReleasing_sequentiallyConsistent", test_Int32_compareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_Int32_compareExchange_relaxed", test_Int32_compareExchange_relaxed), + ("test_Int32_compareExchange_relaxed_acquiring", test_Int32_compareExchange_relaxed_acquiring), + ("test_Int32_compareExchange_relaxed_relaxed", test_Int32_compareExchange_relaxed_relaxed), + ("test_Int32_compareExchange_relaxed_sequentiallyConsistent", test_Int32_compareExchange_relaxed_sequentiallyConsistent), + ("test_Int32_compareExchange_releasing", test_Int32_compareExchange_releasing), + ("test_Int32_compareExchange_releasing_acquiring", test_Int32_compareExchange_releasing_acquiring), + ("test_Int32_compareExchange_releasing_relaxed", test_Int32_compareExchange_releasing_relaxed), + ("test_Int32_compareExchange_releasing_sequentiallyConsistent", test_Int32_compareExchange_releasing_sequentiallyConsistent), + ("test_Int32_compareExchange_sequentiallyConsistent", test_Int32_compareExchange_sequentiallyConsistent), + ("test_Int32_compareExchange_sequentiallyConsistent_acquiring", test_Int32_compareExchange_sequentiallyConsistent_acquiring), + ("test_Int32_compareExchange_sequentiallyConsistent_relaxed", test_Int32_compareExchange_sequentiallyConsistent_relaxed), + ("test_Int32_compareExchange_sequentiallyConsistent_sequentiallyConsistent", test_Int32_compareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_Int32_create_destroy", test_Int32_create_destroy), + ("test_Int32_exchange_acquiring", test_Int32_exchange_acquiring), + ("test_Int32_exchange_acquiringAndReleasing", test_Int32_exchange_acquiringAndReleasing), + ("test_Int32_exchange_relaxed", test_Int32_exchange_relaxed), + ("test_Int32_exchange_releasing", test_Int32_exchange_releasing), + ("test_Int32_exchange_sequentiallyConsistent", test_Int32_exchange_sequentiallyConsistent), + ("test_Int32_load_acquiring", test_Int32_load_acquiring), + ("test_Int32_load_relaxed", test_Int32_load_relaxed), + ("test_Int32_load_sequentiallyConsistent", test_Int32_load_sequentiallyConsistent), + ("test_Int32_loadThenBitwiseAnd_acquiring", test_Int32_loadThenBitwiseAnd_acquiring), + ("test_Int32_loadThenBitwiseAnd_acquiringAndReleasing", test_Int32_loadThenBitwiseAnd_acquiringAndReleasing), + ("test_Int32_loadThenBitwiseAnd_relaxed", test_Int32_loadThenBitwiseAnd_relaxed), + ("test_Int32_loadThenBitwiseAnd_releasing", test_Int32_loadThenBitwiseAnd_releasing), + ("test_Int32_loadThenBitwiseAnd_sequentiallyConsistent", test_Int32_loadThenBitwiseAnd_sequentiallyConsistent), + ("test_Int32_loadThenBitwiseOr_acquiring", test_Int32_loadThenBitwiseOr_acquiring), + ("test_Int32_loadThenBitwiseOr_acquiringAndReleasing", test_Int32_loadThenBitwiseOr_acquiringAndReleasing), + ("test_Int32_loadThenBitwiseOr_relaxed", test_Int32_loadThenBitwiseOr_relaxed), + ("test_Int32_loadThenBitwiseOr_releasing", test_Int32_loadThenBitwiseOr_releasing), + ("test_Int32_loadThenBitwiseOr_sequentiallyConsistent", test_Int32_loadThenBitwiseOr_sequentiallyConsistent), + ("test_Int32_loadThenBitwiseXor_acquiring", test_Int32_loadThenBitwiseXor_acquiring), + ("test_Int32_loadThenBitwiseXor_acquiringAndReleasing", test_Int32_loadThenBitwiseXor_acquiringAndReleasing), + ("test_Int32_loadThenBitwiseXor_relaxed", test_Int32_loadThenBitwiseXor_relaxed), + ("test_Int32_loadThenBitwiseXor_releasing", test_Int32_loadThenBitwiseXor_releasing), + ("test_Int32_loadThenBitwiseXor_sequentiallyConsistent", test_Int32_loadThenBitwiseXor_sequentiallyConsistent), + ("test_Int32_loadThenWrappingDecrement_acquiring", test_Int32_loadThenWrappingDecrement_acquiring), + ("test_Int32_loadThenWrappingDecrement_acquiringAndReleasing", test_Int32_loadThenWrappingDecrement_acquiringAndReleasing), + ("test_Int32_loadThenWrappingDecrement_relaxed", test_Int32_loadThenWrappingDecrement_relaxed), + ("test_Int32_loadThenWrappingDecrement_releasing", test_Int32_loadThenWrappingDecrement_releasing), + ("test_Int32_loadThenWrappingDecrement_sequentiallyConsistent", test_Int32_loadThenWrappingDecrement_sequentiallyConsistent), + ("test_Int32_loadThenWrappingIncrement_acquiring", test_Int32_loadThenWrappingIncrement_acquiring), + ("test_Int32_loadThenWrappingIncrement_acquiringAndReleasing", test_Int32_loadThenWrappingIncrement_acquiringAndReleasing), + ("test_Int32_loadThenWrappingIncrement_relaxed", test_Int32_loadThenWrappingIncrement_relaxed), + ("test_Int32_loadThenWrappingIncrement_releasing", test_Int32_loadThenWrappingIncrement_releasing), + ("test_Int32_loadThenWrappingIncrement_sequentiallyConsistent", test_Int32_loadThenWrappingIncrement_sequentiallyConsistent), + ("test_Int32_store_relaxed", test_Int32_store_relaxed), + ("test_Int32_store_releasing", test_Int32_store_releasing), + ("test_Int32_store_sequentiallyConsistent", test_Int32_store_sequentiallyConsistent), + ("test_Int32_weakCompareExchange_acquiring_acquiring", test_Int32_weakCompareExchange_acquiring_acquiring), + ("test_Int32_weakCompareExchange_acquiring_relaxed", test_Int32_weakCompareExchange_acquiring_relaxed), + ("test_Int32_weakCompareExchange_acquiring_sequentiallyConsistent", test_Int32_weakCompareExchange_acquiring_sequentiallyConsistent), + ("test_Int32_weakCompareExchange_acquiringAndReleasing_acquiring", test_Int32_weakCompareExchange_acquiringAndReleasing_acquiring), + ("test_Int32_weakCompareExchange_acquiringAndReleasing_relaxed", test_Int32_weakCompareExchange_acquiringAndReleasing_relaxed), + ("test_Int32_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent", test_Int32_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_Int32_weakCompareExchange_relaxed_acquiring", test_Int32_weakCompareExchange_relaxed_acquiring), + ("test_Int32_weakCompareExchange_relaxed_relaxed", test_Int32_weakCompareExchange_relaxed_relaxed), + ("test_Int32_weakCompareExchange_relaxed_sequentiallyConsistent", test_Int32_weakCompareExchange_relaxed_sequentiallyConsistent), + ("test_Int32_weakCompareExchange_releasing_acquiring", test_Int32_weakCompareExchange_releasing_acquiring), + ("test_Int32_weakCompareExchange_releasing_relaxed", test_Int32_weakCompareExchange_releasing_relaxed), + ("test_Int32_weakCompareExchange_releasing_sequentiallyConsistent", test_Int32_weakCompareExchange_releasing_sequentiallyConsistent), + ("test_Int32_weakCompareExchange_sequentiallyConsistent_acquiring", test_Int32_weakCompareExchange_sequentiallyConsistent_acquiring), + ("test_Int32_weakCompareExchange_sequentiallyConsistent_relaxed", test_Int32_weakCompareExchange_sequentiallyConsistent_relaxed), + ("test_Int32_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent", test_Int32_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_Int32_wrappingDecrementThenLoad_acquiring", test_Int32_wrappingDecrementThenLoad_acquiring), + ("test_Int32_wrappingDecrementThenLoad_acquiringAndReleasing", test_Int32_wrappingDecrementThenLoad_acquiringAndReleasing), + ("test_Int32_wrappingDecrementThenLoad_relaxed", test_Int32_wrappingDecrementThenLoad_relaxed), + ("test_Int32_wrappingDecrementThenLoad_releasing", test_Int32_wrappingDecrementThenLoad_releasing), + ("test_Int32_wrappingDecrementThenLoad_sequentiallyConsistent", test_Int32_wrappingDecrementThenLoad_sequentiallyConsistent), + ("test_Int32_wrappingIncrementThenLoad_acquiring", test_Int32_wrappingIncrementThenLoad_acquiring), + ("test_Int32_wrappingIncrementThenLoad_acquiringAndReleasing", test_Int32_wrappingIncrementThenLoad_acquiringAndReleasing), + ("test_Int32_wrappingIncrementThenLoad_relaxed", test_Int32_wrappingIncrementThenLoad_relaxed), + ("test_Int32_wrappingIncrementThenLoad_releasing", test_Int32_wrappingIncrementThenLoad_releasing), + ("test_Int32_wrappingIncrementThenLoad_sequentiallyConsistent", test_Int32_wrappingIncrementThenLoad_sequentiallyConsistent), + ("test_Int64_bitwiseAndThenLoad_acquiring", test_Int64_bitwiseAndThenLoad_acquiring), + ("test_Int64_bitwiseAndThenLoad_acquiringAndReleasing", test_Int64_bitwiseAndThenLoad_acquiringAndReleasing), + ("test_Int64_bitwiseAndThenLoad_relaxed", test_Int64_bitwiseAndThenLoad_relaxed), + ("test_Int64_bitwiseAndThenLoad_releasing", test_Int64_bitwiseAndThenLoad_releasing), + ("test_Int64_bitwiseAndThenLoad_sequentiallyConsistent", test_Int64_bitwiseAndThenLoad_sequentiallyConsistent), + ("test_Int64_bitwiseOrThenLoad_acquiring", test_Int64_bitwiseOrThenLoad_acquiring), + ("test_Int64_bitwiseOrThenLoad_acquiringAndReleasing", test_Int64_bitwiseOrThenLoad_acquiringAndReleasing), + ("test_Int64_bitwiseOrThenLoad_relaxed", test_Int64_bitwiseOrThenLoad_relaxed), + ("test_Int64_bitwiseOrThenLoad_releasing", test_Int64_bitwiseOrThenLoad_releasing), + ("test_Int64_bitwiseOrThenLoad_sequentiallyConsistent", test_Int64_bitwiseOrThenLoad_sequentiallyConsistent), + ("test_Int64_bitwiseXorThenLoad_acquiring", test_Int64_bitwiseXorThenLoad_acquiring), + ("test_Int64_bitwiseXorThenLoad_acquiringAndReleasing", test_Int64_bitwiseXorThenLoad_acquiringAndReleasing), + ("test_Int64_bitwiseXorThenLoad_relaxed", test_Int64_bitwiseXorThenLoad_relaxed), + ("test_Int64_bitwiseXorThenLoad_releasing", test_Int64_bitwiseXorThenLoad_releasing), + ("test_Int64_bitwiseXorThenLoad_sequentiallyConsistent", test_Int64_bitwiseXorThenLoad_sequentiallyConsistent), + ("test_Int64_compareExchange_acquiring", test_Int64_compareExchange_acquiring), + ("test_Int64_compareExchange_acquiring_acquiring", test_Int64_compareExchange_acquiring_acquiring), + ("test_Int64_compareExchange_acquiring_relaxed", test_Int64_compareExchange_acquiring_relaxed), + ("test_Int64_compareExchange_acquiring_sequentiallyConsistent", test_Int64_compareExchange_acquiring_sequentiallyConsistent), + ("test_Int64_compareExchange_acquiringAndReleasing", test_Int64_compareExchange_acquiringAndReleasing), + ("test_Int64_compareExchange_acquiringAndReleasing_acquiring", test_Int64_compareExchange_acquiringAndReleasing_acquiring), + ("test_Int64_compareExchange_acquiringAndReleasing_relaxed", test_Int64_compareExchange_acquiringAndReleasing_relaxed), + ("test_Int64_compareExchange_acquiringAndReleasing_sequentiallyConsistent", test_Int64_compareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_Int64_compareExchange_relaxed", test_Int64_compareExchange_relaxed), + ("test_Int64_compareExchange_relaxed_acquiring", test_Int64_compareExchange_relaxed_acquiring), + ("test_Int64_compareExchange_relaxed_relaxed", test_Int64_compareExchange_relaxed_relaxed), + ("test_Int64_compareExchange_relaxed_sequentiallyConsistent", test_Int64_compareExchange_relaxed_sequentiallyConsistent), + ("test_Int64_compareExchange_releasing", test_Int64_compareExchange_releasing), + ("test_Int64_compareExchange_releasing_acquiring", test_Int64_compareExchange_releasing_acquiring), + ("test_Int64_compareExchange_releasing_relaxed", test_Int64_compareExchange_releasing_relaxed), + ("test_Int64_compareExchange_releasing_sequentiallyConsistent", test_Int64_compareExchange_releasing_sequentiallyConsistent), + ("test_Int64_compareExchange_sequentiallyConsistent", test_Int64_compareExchange_sequentiallyConsistent), + ("test_Int64_compareExchange_sequentiallyConsistent_acquiring", test_Int64_compareExchange_sequentiallyConsistent_acquiring), + ("test_Int64_compareExchange_sequentiallyConsistent_relaxed", test_Int64_compareExchange_sequentiallyConsistent_relaxed), + ("test_Int64_compareExchange_sequentiallyConsistent_sequentiallyConsistent", test_Int64_compareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_Int64_create_destroy", test_Int64_create_destroy), + ("test_Int64_exchange_acquiring", test_Int64_exchange_acquiring), + ("test_Int64_exchange_acquiringAndReleasing", test_Int64_exchange_acquiringAndReleasing), + ("test_Int64_exchange_relaxed", test_Int64_exchange_relaxed), + ("test_Int64_exchange_releasing", test_Int64_exchange_releasing), + ("test_Int64_exchange_sequentiallyConsistent", test_Int64_exchange_sequentiallyConsistent), + ("test_Int64_load_acquiring", test_Int64_load_acquiring), + ("test_Int64_load_relaxed", test_Int64_load_relaxed), + ("test_Int64_load_sequentiallyConsistent", test_Int64_load_sequentiallyConsistent), + ("test_Int64_loadThenBitwiseAnd_acquiring", test_Int64_loadThenBitwiseAnd_acquiring), + ("test_Int64_loadThenBitwiseAnd_acquiringAndReleasing", test_Int64_loadThenBitwiseAnd_acquiringAndReleasing), + ("test_Int64_loadThenBitwiseAnd_relaxed", test_Int64_loadThenBitwiseAnd_relaxed), + ("test_Int64_loadThenBitwiseAnd_releasing", test_Int64_loadThenBitwiseAnd_releasing), + ("test_Int64_loadThenBitwiseAnd_sequentiallyConsistent", test_Int64_loadThenBitwiseAnd_sequentiallyConsistent), + ("test_Int64_loadThenBitwiseOr_acquiring", test_Int64_loadThenBitwiseOr_acquiring), + ("test_Int64_loadThenBitwiseOr_acquiringAndReleasing", test_Int64_loadThenBitwiseOr_acquiringAndReleasing), + ("test_Int64_loadThenBitwiseOr_relaxed", test_Int64_loadThenBitwiseOr_relaxed), + ("test_Int64_loadThenBitwiseOr_releasing", test_Int64_loadThenBitwiseOr_releasing), + ("test_Int64_loadThenBitwiseOr_sequentiallyConsistent", test_Int64_loadThenBitwiseOr_sequentiallyConsistent), + ("test_Int64_loadThenBitwiseXor_acquiring", test_Int64_loadThenBitwiseXor_acquiring), + ("test_Int64_loadThenBitwiseXor_acquiringAndReleasing", test_Int64_loadThenBitwiseXor_acquiringAndReleasing), + ("test_Int64_loadThenBitwiseXor_relaxed", test_Int64_loadThenBitwiseXor_relaxed), + ("test_Int64_loadThenBitwiseXor_releasing", test_Int64_loadThenBitwiseXor_releasing), + ("test_Int64_loadThenBitwiseXor_sequentiallyConsistent", test_Int64_loadThenBitwiseXor_sequentiallyConsistent), + ("test_Int64_loadThenWrappingDecrement_acquiring", test_Int64_loadThenWrappingDecrement_acquiring), + ("test_Int64_loadThenWrappingDecrement_acquiringAndReleasing", test_Int64_loadThenWrappingDecrement_acquiringAndReleasing), + ("test_Int64_loadThenWrappingDecrement_relaxed", test_Int64_loadThenWrappingDecrement_relaxed), + ("test_Int64_loadThenWrappingDecrement_releasing", test_Int64_loadThenWrappingDecrement_releasing), + ("test_Int64_loadThenWrappingDecrement_sequentiallyConsistent", test_Int64_loadThenWrappingDecrement_sequentiallyConsistent), + ("test_Int64_loadThenWrappingIncrement_acquiring", test_Int64_loadThenWrappingIncrement_acquiring), + ("test_Int64_loadThenWrappingIncrement_acquiringAndReleasing", test_Int64_loadThenWrappingIncrement_acquiringAndReleasing), + ("test_Int64_loadThenWrappingIncrement_relaxed", test_Int64_loadThenWrappingIncrement_relaxed), + ("test_Int64_loadThenWrappingIncrement_releasing", test_Int64_loadThenWrappingIncrement_releasing), + ("test_Int64_loadThenWrappingIncrement_sequentiallyConsistent", test_Int64_loadThenWrappingIncrement_sequentiallyConsistent), + ("test_Int64_store_relaxed", test_Int64_store_relaxed), + ("test_Int64_store_releasing", test_Int64_store_releasing), + ("test_Int64_store_sequentiallyConsistent", test_Int64_store_sequentiallyConsistent), + ("test_Int64_weakCompareExchange_acquiring_acquiring", test_Int64_weakCompareExchange_acquiring_acquiring), + ("test_Int64_weakCompareExchange_acquiring_relaxed", test_Int64_weakCompareExchange_acquiring_relaxed), + ("test_Int64_weakCompareExchange_acquiring_sequentiallyConsistent", test_Int64_weakCompareExchange_acquiring_sequentiallyConsistent), + ("test_Int64_weakCompareExchange_acquiringAndReleasing_acquiring", test_Int64_weakCompareExchange_acquiringAndReleasing_acquiring), + ("test_Int64_weakCompareExchange_acquiringAndReleasing_relaxed", test_Int64_weakCompareExchange_acquiringAndReleasing_relaxed), + ("test_Int64_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent", test_Int64_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_Int64_weakCompareExchange_relaxed_acquiring", test_Int64_weakCompareExchange_relaxed_acquiring), + ("test_Int64_weakCompareExchange_relaxed_relaxed", test_Int64_weakCompareExchange_relaxed_relaxed), + ("test_Int64_weakCompareExchange_relaxed_sequentiallyConsistent", test_Int64_weakCompareExchange_relaxed_sequentiallyConsistent), + ("test_Int64_weakCompareExchange_releasing_acquiring", test_Int64_weakCompareExchange_releasing_acquiring), + ("test_Int64_weakCompareExchange_releasing_relaxed", test_Int64_weakCompareExchange_releasing_relaxed), + ("test_Int64_weakCompareExchange_releasing_sequentiallyConsistent", test_Int64_weakCompareExchange_releasing_sequentiallyConsistent), + ("test_Int64_weakCompareExchange_sequentiallyConsistent_acquiring", test_Int64_weakCompareExchange_sequentiallyConsistent_acquiring), + ("test_Int64_weakCompareExchange_sequentiallyConsistent_relaxed", test_Int64_weakCompareExchange_sequentiallyConsistent_relaxed), + ("test_Int64_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent", test_Int64_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_Int64_wrappingDecrementThenLoad_acquiring", test_Int64_wrappingDecrementThenLoad_acquiring), + ("test_Int64_wrappingDecrementThenLoad_acquiringAndReleasing", test_Int64_wrappingDecrementThenLoad_acquiringAndReleasing), + ("test_Int64_wrappingDecrementThenLoad_relaxed", test_Int64_wrappingDecrementThenLoad_relaxed), + ("test_Int64_wrappingDecrementThenLoad_releasing", test_Int64_wrappingDecrementThenLoad_releasing), + ("test_Int64_wrappingDecrementThenLoad_sequentiallyConsistent", test_Int64_wrappingDecrementThenLoad_sequentiallyConsistent), + ("test_Int64_wrappingIncrementThenLoad_acquiring", test_Int64_wrappingIncrementThenLoad_acquiring), + ("test_Int64_wrappingIncrementThenLoad_acquiringAndReleasing", test_Int64_wrappingIncrementThenLoad_acquiringAndReleasing), + ("test_Int64_wrappingIncrementThenLoad_relaxed", test_Int64_wrappingIncrementThenLoad_relaxed), + ("test_Int64_wrappingIncrementThenLoad_releasing", test_Int64_wrappingIncrementThenLoad_releasing), + ("test_Int64_wrappingIncrementThenLoad_sequentiallyConsistent", test_Int64_wrappingIncrementThenLoad_sequentiallyConsistent), + ("test_Int8_bitwiseAndThenLoad_acquiring", test_Int8_bitwiseAndThenLoad_acquiring), + ("test_Int8_bitwiseAndThenLoad_acquiringAndReleasing", test_Int8_bitwiseAndThenLoad_acquiringAndReleasing), + ("test_Int8_bitwiseAndThenLoad_relaxed", test_Int8_bitwiseAndThenLoad_relaxed), + ("test_Int8_bitwiseAndThenLoad_releasing", test_Int8_bitwiseAndThenLoad_releasing), + ("test_Int8_bitwiseAndThenLoad_sequentiallyConsistent", test_Int8_bitwiseAndThenLoad_sequentiallyConsistent), + ("test_Int8_bitwiseOrThenLoad_acquiring", test_Int8_bitwiseOrThenLoad_acquiring), + ("test_Int8_bitwiseOrThenLoad_acquiringAndReleasing", test_Int8_bitwiseOrThenLoad_acquiringAndReleasing), + ("test_Int8_bitwiseOrThenLoad_relaxed", test_Int8_bitwiseOrThenLoad_relaxed), + ("test_Int8_bitwiseOrThenLoad_releasing", test_Int8_bitwiseOrThenLoad_releasing), + ("test_Int8_bitwiseOrThenLoad_sequentiallyConsistent", test_Int8_bitwiseOrThenLoad_sequentiallyConsistent), + ("test_Int8_bitwiseXorThenLoad_acquiring", test_Int8_bitwiseXorThenLoad_acquiring), + ("test_Int8_bitwiseXorThenLoad_acquiringAndReleasing", test_Int8_bitwiseXorThenLoad_acquiringAndReleasing), + ("test_Int8_bitwiseXorThenLoad_relaxed", test_Int8_bitwiseXorThenLoad_relaxed), + ("test_Int8_bitwiseXorThenLoad_releasing", test_Int8_bitwiseXorThenLoad_releasing), + ("test_Int8_bitwiseXorThenLoad_sequentiallyConsistent", test_Int8_bitwiseXorThenLoad_sequentiallyConsistent), + ("test_Int8_compareExchange_acquiring", test_Int8_compareExchange_acquiring), + ("test_Int8_compareExchange_acquiring_acquiring", test_Int8_compareExchange_acquiring_acquiring), + ("test_Int8_compareExchange_acquiring_relaxed", test_Int8_compareExchange_acquiring_relaxed), + ("test_Int8_compareExchange_acquiring_sequentiallyConsistent", test_Int8_compareExchange_acquiring_sequentiallyConsistent), + ("test_Int8_compareExchange_acquiringAndReleasing", test_Int8_compareExchange_acquiringAndReleasing), + ("test_Int8_compareExchange_acquiringAndReleasing_acquiring", test_Int8_compareExchange_acquiringAndReleasing_acquiring), + ("test_Int8_compareExchange_acquiringAndReleasing_relaxed", test_Int8_compareExchange_acquiringAndReleasing_relaxed), + ("test_Int8_compareExchange_acquiringAndReleasing_sequentiallyConsistent", test_Int8_compareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_Int8_compareExchange_relaxed", test_Int8_compareExchange_relaxed), + ("test_Int8_compareExchange_relaxed_acquiring", test_Int8_compareExchange_relaxed_acquiring), + ("test_Int8_compareExchange_relaxed_relaxed", test_Int8_compareExchange_relaxed_relaxed), + ("test_Int8_compareExchange_relaxed_sequentiallyConsistent", test_Int8_compareExchange_relaxed_sequentiallyConsistent), + ("test_Int8_compareExchange_releasing", test_Int8_compareExchange_releasing), + ("test_Int8_compareExchange_releasing_acquiring", test_Int8_compareExchange_releasing_acquiring), + ("test_Int8_compareExchange_releasing_relaxed", test_Int8_compareExchange_releasing_relaxed), + ("test_Int8_compareExchange_releasing_sequentiallyConsistent", test_Int8_compareExchange_releasing_sequentiallyConsistent), + ("test_Int8_compareExchange_sequentiallyConsistent", test_Int8_compareExchange_sequentiallyConsistent), + ("test_Int8_compareExchange_sequentiallyConsistent_acquiring", test_Int8_compareExchange_sequentiallyConsistent_acquiring), + ("test_Int8_compareExchange_sequentiallyConsistent_relaxed", test_Int8_compareExchange_sequentiallyConsistent_relaxed), + ("test_Int8_compareExchange_sequentiallyConsistent_sequentiallyConsistent", test_Int8_compareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_Int8_create_destroy", test_Int8_create_destroy), + ("test_Int8_exchange_acquiring", test_Int8_exchange_acquiring), + ("test_Int8_exchange_acquiringAndReleasing", test_Int8_exchange_acquiringAndReleasing), + ("test_Int8_exchange_relaxed", test_Int8_exchange_relaxed), + ("test_Int8_exchange_releasing", test_Int8_exchange_releasing), + ("test_Int8_exchange_sequentiallyConsistent", test_Int8_exchange_sequentiallyConsistent), + ("test_Int8_load_acquiring", test_Int8_load_acquiring), + ("test_Int8_load_relaxed", test_Int8_load_relaxed), + ("test_Int8_load_sequentiallyConsistent", test_Int8_load_sequentiallyConsistent), + ("test_Int8_loadThenBitwiseAnd_acquiring", test_Int8_loadThenBitwiseAnd_acquiring), + ("test_Int8_loadThenBitwiseAnd_acquiringAndReleasing", test_Int8_loadThenBitwiseAnd_acquiringAndReleasing), + ("test_Int8_loadThenBitwiseAnd_relaxed", test_Int8_loadThenBitwiseAnd_relaxed), + ("test_Int8_loadThenBitwiseAnd_releasing", test_Int8_loadThenBitwiseAnd_releasing), + ("test_Int8_loadThenBitwiseAnd_sequentiallyConsistent", test_Int8_loadThenBitwiseAnd_sequentiallyConsistent), + ("test_Int8_loadThenBitwiseOr_acquiring", test_Int8_loadThenBitwiseOr_acquiring), + ("test_Int8_loadThenBitwiseOr_acquiringAndReleasing", test_Int8_loadThenBitwiseOr_acquiringAndReleasing), + ("test_Int8_loadThenBitwiseOr_relaxed", test_Int8_loadThenBitwiseOr_relaxed), + ("test_Int8_loadThenBitwiseOr_releasing", test_Int8_loadThenBitwiseOr_releasing), + ("test_Int8_loadThenBitwiseOr_sequentiallyConsistent", test_Int8_loadThenBitwiseOr_sequentiallyConsistent), + ("test_Int8_loadThenBitwiseXor_acquiring", test_Int8_loadThenBitwiseXor_acquiring), + ("test_Int8_loadThenBitwiseXor_acquiringAndReleasing", test_Int8_loadThenBitwiseXor_acquiringAndReleasing), + ("test_Int8_loadThenBitwiseXor_relaxed", test_Int8_loadThenBitwiseXor_relaxed), + ("test_Int8_loadThenBitwiseXor_releasing", test_Int8_loadThenBitwiseXor_releasing), + ("test_Int8_loadThenBitwiseXor_sequentiallyConsistent", test_Int8_loadThenBitwiseXor_sequentiallyConsistent), + ("test_Int8_loadThenWrappingDecrement_acquiring", test_Int8_loadThenWrappingDecrement_acquiring), + ("test_Int8_loadThenWrappingDecrement_acquiringAndReleasing", test_Int8_loadThenWrappingDecrement_acquiringAndReleasing), + ("test_Int8_loadThenWrappingDecrement_relaxed", test_Int8_loadThenWrappingDecrement_relaxed), + ("test_Int8_loadThenWrappingDecrement_releasing", test_Int8_loadThenWrappingDecrement_releasing), + ("test_Int8_loadThenWrappingDecrement_sequentiallyConsistent", test_Int8_loadThenWrappingDecrement_sequentiallyConsistent), + ("test_Int8_loadThenWrappingIncrement_acquiring", test_Int8_loadThenWrappingIncrement_acquiring), + ("test_Int8_loadThenWrappingIncrement_acquiringAndReleasing", test_Int8_loadThenWrappingIncrement_acquiringAndReleasing), + ("test_Int8_loadThenWrappingIncrement_relaxed", test_Int8_loadThenWrappingIncrement_relaxed), + ("test_Int8_loadThenWrappingIncrement_releasing", test_Int8_loadThenWrappingIncrement_releasing), + ("test_Int8_loadThenWrappingIncrement_sequentiallyConsistent", test_Int8_loadThenWrappingIncrement_sequentiallyConsistent), + ("test_Int8_store_relaxed", test_Int8_store_relaxed), + ("test_Int8_store_releasing", test_Int8_store_releasing), + ("test_Int8_store_sequentiallyConsistent", test_Int8_store_sequentiallyConsistent), + ("test_Int8_weakCompareExchange_acquiring_acquiring", test_Int8_weakCompareExchange_acquiring_acquiring), + ("test_Int8_weakCompareExchange_acquiring_relaxed", test_Int8_weakCompareExchange_acquiring_relaxed), + ("test_Int8_weakCompareExchange_acquiring_sequentiallyConsistent", test_Int8_weakCompareExchange_acquiring_sequentiallyConsistent), + ("test_Int8_weakCompareExchange_acquiringAndReleasing_acquiring", test_Int8_weakCompareExchange_acquiringAndReleasing_acquiring), + ("test_Int8_weakCompareExchange_acquiringAndReleasing_relaxed", test_Int8_weakCompareExchange_acquiringAndReleasing_relaxed), + ("test_Int8_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent", test_Int8_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_Int8_weakCompareExchange_relaxed_acquiring", test_Int8_weakCompareExchange_relaxed_acquiring), + ("test_Int8_weakCompareExchange_relaxed_relaxed", test_Int8_weakCompareExchange_relaxed_relaxed), + ("test_Int8_weakCompareExchange_relaxed_sequentiallyConsistent", test_Int8_weakCompareExchange_relaxed_sequentiallyConsistent), + ("test_Int8_weakCompareExchange_releasing_acquiring", test_Int8_weakCompareExchange_releasing_acquiring), + ("test_Int8_weakCompareExchange_releasing_relaxed", test_Int8_weakCompareExchange_releasing_relaxed), + ("test_Int8_weakCompareExchange_releasing_sequentiallyConsistent", test_Int8_weakCompareExchange_releasing_sequentiallyConsistent), + ("test_Int8_weakCompareExchange_sequentiallyConsistent_acquiring", test_Int8_weakCompareExchange_sequentiallyConsistent_acquiring), + ("test_Int8_weakCompareExchange_sequentiallyConsistent_relaxed", test_Int8_weakCompareExchange_sequentiallyConsistent_relaxed), + ("test_Int8_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent", test_Int8_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_Int8_wrappingDecrementThenLoad_acquiring", test_Int8_wrappingDecrementThenLoad_acquiring), + ("test_Int8_wrappingDecrementThenLoad_acquiringAndReleasing", test_Int8_wrappingDecrementThenLoad_acquiringAndReleasing), + ("test_Int8_wrappingDecrementThenLoad_relaxed", test_Int8_wrappingDecrementThenLoad_relaxed), + ("test_Int8_wrappingDecrementThenLoad_releasing", test_Int8_wrappingDecrementThenLoad_releasing), + ("test_Int8_wrappingDecrementThenLoad_sequentiallyConsistent", test_Int8_wrappingDecrementThenLoad_sequentiallyConsistent), + ("test_Int8_wrappingIncrementThenLoad_acquiring", test_Int8_wrappingIncrementThenLoad_acquiring), + ("test_Int8_wrappingIncrementThenLoad_acquiringAndReleasing", test_Int8_wrappingIncrementThenLoad_acquiringAndReleasing), + ("test_Int8_wrappingIncrementThenLoad_relaxed", test_Int8_wrappingIncrementThenLoad_relaxed), + ("test_Int8_wrappingIncrementThenLoad_releasing", test_Int8_wrappingIncrementThenLoad_releasing), + ("test_Int8_wrappingIncrementThenLoad_sequentiallyConsistent", test_Int8_wrappingIncrementThenLoad_sequentiallyConsistent), + ("test_Int_bitwiseAndThenLoad_acquiring", test_Int_bitwiseAndThenLoad_acquiring), + ("test_Int_bitwiseAndThenLoad_acquiringAndReleasing", test_Int_bitwiseAndThenLoad_acquiringAndReleasing), + ("test_Int_bitwiseAndThenLoad_relaxed", test_Int_bitwiseAndThenLoad_relaxed), + ("test_Int_bitwiseAndThenLoad_releasing", test_Int_bitwiseAndThenLoad_releasing), + ("test_Int_bitwiseAndThenLoad_sequentiallyConsistent", test_Int_bitwiseAndThenLoad_sequentiallyConsistent), + ("test_Int_bitwiseOrThenLoad_acquiring", test_Int_bitwiseOrThenLoad_acquiring), + ("test_Int_bitwiseOrThenLoad_acquiringAndReleasing", test_Int_bitwiseOrThenLoad_acquiringAndReleasing), + ("test_Int_bitwiseOrThenLoad_relaxed", test_Int_bitwiseOrThenLoad_relaxed), + ("test_Int_bitwiseOrThenLoad_releasing", test_Int_bitwiseOrThenLoad_releasing), + ("test_Int_bitwiseOrThenLoad_sequentiallyConsistent", test_Int_bitwiseOrThenLoad_sequentiallyConsistent), + ("test_Int_bitwiseXorThenLoad_acquiring", test_Int_bitwiseXorThenLoad_acquiring), + ("test_Int_bitwiseXorThenLoad_acquiringAndReleasing", test_Int_bitwiseXorThenLoad_acquiringAndReleasing), + ("test_Int_bitwiseXorThenLoad_relaxed", test_Int_bitwiseXorThenLoad_relaxed), + ("test_Int_bitwiseXorThenLoad_releasing", test_Int_bitwiseXorThenLoad_releasing), + ("test_Int_bitwiseXorThenLoad_sequentiallyConsistent", test_Int_bitwiseXorThenLoad_sequentiallyConsistent), + ("test_Int_compareExchange_acquiring", test_Int_compareExchange_acquiring), + ("test_Int_compareExchange_acquiring_acquiring", test_Int_compareExchange_acquiring_acquiring), + ("test_Int_compareExchange_acquiring_relaxed", test_Int_compareExchange_acquiring_relaxed), + ("test_Int_compareExchange_acquiring_sequentiallyConsistent", test_Int_compareExchange_acquiring_sequentiallyConsistent), + ("test_Int_compareExchange_acquiringAndReleasing", test_Int_compareExchange_acquiringAndReleasing), + ("test_Int_compareExchange_acquiringAndReleasing_acquiring", test_Int_compareExchange_acquiringAndReleasing_acquiring), + ("test_Int_compareExchange_acquiringAndReleasing_relaxed", test_Int_compareExchange_acquiringAndReleasing_relaxed), + ("test_Int_compareExchange_acquiringAndReleasing_sequentiallyConsistent", test_Int_compareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_Int_compareExchange_relaxed", test_Int_compareExchange_relaxed), + ("test_Int_compareExchange_relaxed_acquiring", test_Int_compareExchange_relaxed_acquiring), + ("test_Int_compareExchange_relaxed_relaxed", test_Int_compareExchange_relaxed_relaxed), + ("test_Int_compareExchange_relaxed_sequentiallyConsistent", test_Int_compareExchange_relaxed_sequentiallyConsistent), + ("test_Int_compareExchange_releasing", test_Int_compareExchange_releasing), + ("test_Int_compareExchange_releasing_acquiring", test_Int_compareExchange_releasing_acquiring), + ("test_Int_compareExchange_releasing_relaxed", test_Int_compareExchange_releasing_relaxed), + ("test_Int_compareExchange_releasing_sequentiallyConsistent", test_Int_compareExchange_releasing_sequentiallyConsistent), + ("test_Int_compareExchange_sequentiallyConsistent", test_Int_compareExchange_sequentiallyConsistent), + ("test_Int_compareExchange_sequentiallyConsistent_acquiring", test_Int_compareExchange_sequentiallyConsistent_acquiring), + ("test_Int_compareExchange_sequentiallyConsistent_relaxed", test_Int_compareExchange_sequentiallyConsistent_relaxed), + ("test_Int_compareExchange_sequentiallyConsistent_sequentiallyConsistent", test_Int_compareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_Int_create_destroy", test_Int_create_destroy), + ("test_Int_exchange_acquiring", test_Int_exchange_acquiring), + ("test_Int_exchange_acquiringAndReleasing", test_Int_exchange_acquiringAndReleasing), + ("test_Int_exchange_relaxed", test_Int_exchange_relaxed), + ("test_Int_exchange_releasing", test_Int_exchange_releasing), + ("test_Int_exchange_sequentiallyConsistent", test_Int_exchange_sequentiallyConsistent), + ("test_Int_load_acquiring", test_Int_load_acquiring), + ("test_Int_load_relaxed", test_Int_load_relaxed), + ("test_Int_load_sequentiallyConsistent", test_Int_load_sequentiallyConsistent), + ("test_Int_loadThenBitwiseAnd_acquiring", test_Int_loadThenBitwiseAnd_acquiring), + ("test_Int_loadThenBitwiseAnd_acquiringAndReleasing", test_Int_loadThenBitwiseAnd_acquiringAndReleasing), + ("test_Int_loadThenBitwiseAnd_relaxed", test_Int_loadThenBitwiseAnd_relaxed), + ("test_Int_loadThenBitwiseAnd_releasing", test_Int_loadThenBitwiseAnd_releasing), + ("test_Int_loadThenBitwiseAnd_sequentiallyConsistent", test_Int_loadThenBitwiseAnd_sequentiallyConsistent), + ("test_Int_loadThenBitwiseOr_acquiring", test_Int_loadThenBitwiseOr_acquiring), + ("test_Int_loadThenBitwiseOr_acquiringAndReleasing", test_Int_loadThenBitwiseOr_acquiringAndReleasing), + ("test_Int_loadThenBitwiseOr_relaxed", test_Int_loadThenBitwiseOr_relaxed), + ("test_Int_loadThenBitwiseOr_releasing", test_Int_loadThenBitwiseOr_releasing), + ("test_Int_loadThenBitwiseOr_sequentiallyConsistent", test_Int_loadThenBitwiseOr_sequentiallyConsistent), + ("test_Int_loadThenBitwiseXor_acquiring", test_Int_loadThenBitwiseXor_acquiring), + ("test_Int_loadThenBitwiseXor_acquiringAndReleasing", test_Int_loadThenBitwiseXor_acquiringAndReleasing), + ("test_Int_loadThenBitwiseXor_relaxed", test_Int_loadThenBitwiseXor_relaxed), + ("test_Int_loadThenBitwiseXor_releasing", test_Int_loadThenBitwiseXor_releasing), + ("test_Int_loadThenBitwiseXor_sequentiallyConsistent", test_Int_loadThenBitwiseXor_sequentiallyConsistent), + ("test_Int_loadThenWrappingDecrement_acquiring", test_Int_loadThenWrappingDecrement_acquiring), + ("test_Int_loadThenWrappingDecrement_acquiringAndReleasing", test_Int_loadThenWrappingDecrement_acquiringAndReleasing), + ("test_Int_loadThenWrappingDecrement_relaxed", test_Int_loadThenWrappingDecrement_relaxed), + ("test_Int_loadThenWrappingDecrement_releasing", test_Int_loadThenWrappingDecrement_releasing), + ("test_Int_loadThenWrappingDecrement_sequentiallyConsistent", test_Int_loadThenWrappingDecrement_sequentiallyConsistent), + ("test_Int_loadThenWrappingIncrement_acquiring", test_Int_loadThenWrappingIncrement_acquiring), + ("test_Int_loadThenWrappingIncrement_acquiringAndReleasing", test_Int_loadThenWrappingIncrement_acquiringAndReleasing), + ("test_Int_loadThenWrappingIncrement_relaxed", test_Int_loadThenWrappingIncrement_relaxed), + ("test_Int_loadThenWrappingIncrement_releasing", test_Int_loadThenWrappingIncrement_releasing), + ("test_Int_loadThenWrappingIncrement_sequentiallyConsistent", test_Int_loadThenWrappingIncrement_sequentiallyConsistent), + ("test_Int_store_relaxed", test_Int_store_relaxed), + ("test_Int_store_releasing", test_Int_store_releasing), + ("test_Int_store_sequentiallyConsistent", test_Int_store_sequentiallyConsistent), + ("test_Int_weakCompareExchange_acquiring_acquiring", test_Int_weakCompareExchange_acquiring_acquiring), + ("test_Int_weakCompareExchange_acquiring_relaxed", test_Int_weakCompareExchange_acquiring_relaxed), + ("test_Int_weakCompareExchange_acquiring_sequentiallyConsistent", test_Int_weakCompareExchange_acquiring_sequentiallyConsistent), + ("test_Int_weakCompareExchange_acquiringAndReleasing_acquiring", test_Int_weakCompareExchange_acquiringAndReleasing_acquiring), + ("test_Int_weakCompareExchange_acquiringAndReleasing_relaxed", test_Int_weakCompareExchange_acquiringAndReleasing_relaxed), + ("test_Int_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent", test_Int_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_Int_weakCompareExchange_relaxed_acquiring", test_Int_weakCompareExchange_relaxed_acquiring), + ("test_Int_weakCompareExchange_relaxed_relaxed", test_Int_weakCompareExchange_relaxed_relaxed), + ("test_Int_weakCompareExchange_relaxed_sequentiallyConsistent", test_Int_weakCompareExchange_relaxed_sequentiallyConsistent), + ("test_Int_weakCompareExchange_releasing_acquiring", test_Int_weakCompareExchange_releasing_acquiring), + ("test_Int_weakCompareExchange_releasing_relaxed", test_Int_weakCompareExchange_releasing_relaxed), + ("test_Int_weakCompareExchange_releasing_sequentiallyConsistent", test_Int_weakCompareExchange_releasing_sequentiallyConsistent), + ("test_Int_weakCompareExchange_sequentiallyConsistent_acquiring", test_Int_weakCompareExchange_sequentiallyConsistent_acquiring), + ("test_Int_weakCompareExchange_sequentiallyConsistent_relaxed", test_Int_weakCompareExchange_sequentiallyConsistent_relaxed), + ("test_Int_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent", test_Int_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_Int_wrappingDecrementThenLoad_acquiring", test_Int_wrappingDecrementThenLoad_acquiring), + ("test_Int_wrappingDecrementThenLoad_acquiringAndReleasing", test_Int_wrappingDecrementThenLoad_acquiringAndReleasing), + ("test_Int_wrappingDecrementThenLoad_relaxed", test_Int_wrappingDecrementThenLoad_relaxed), + ("test_Int_wrappingDecrementThenLoad_releasing", test_Int_wrappingDecrementThenLoad_releasing), + ("test_Int_wrappingDecrementThenLoad_sequentiallyConsistent", test_Int_wrappingDecrementThenLoad_sequentiallyConsistent), + ("test_Int_wrappingIncrementThenLoad_acquiring", test_Int_wrappingIncrementThenLoad_acquiring), + ("test_Int_wrappingIncrementThenLoad_acquiringAndReleasing", test_Int_wrappingIncrementThenLoad_acquiringAndReleasing), + ("test_Int_wrappingIncrementThenLoad_relaxed", test_Int_wrappingIncrementThenLoad_relaxed), + ("test_Int_wrappingIncrementThenLoad_releasing", test_Int_wrappingIncrementThenLoad_releasing), + ("test_Int_wrappingIncrementThenLoad_sequentiallyConsistent", test_Int_wrappingIncrementThenLoad_sequentiallyConsistent), + ("test_MutablePointer_compareExchange_acquiring", test_MutablePointer_compareExchange_acquiring), + ("test_MutablePointer_compareExchange_acquiring_acquiring", test_MutablePointer_compareExchange_acquiring_acquiring), + ("test_MutablePointer_compareExchange_acquiring_relaxed", test_MutablePointer_compareExchange_acquiring_relaxed), + ("test_MutablePointer_compareExchange_acquiring_sequentiallyConsistent", test_MutablePointer_compareExchange_acquiring_sequentiallyConsistent), + ("test_MutablePointer_compareExchange_acquiringAndReleasing", test_MutablePointer_compareExchange_acquiringAndReleasing), + ("test_MutablePointer_compareExchange_acquiringAndReleasing_acquiring", test_MutablePointer_compareExchange_acquiringAndReleasing_acquiring), + ("test_MutablePointer_compareExchange_acquiringAndReleasing_relaxed", test_MutablePointer_compareExchange_acquiringAndReleasing_relaxed), + ("test_MutablePointer_compareExchange_acquiringAndReleasing_sequentiallyConsistent", test_MutablePointer_compareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_MutablePointer_compareExchange_relaxed", test_MutablePointer_compareExchange_relaxed), + ("test_MutablePointer_compareExchange_relaxed_acquiring", test_MutablePointer_compareExchange_relaxed_acquiring), + ("test_MutablePointer_compareExchange_relaxed_relaxed", test_MutablePointer_compareExchange_relaxed_relaxed), + ("test_MutablePointer_compareExchange_relaxed_sequentiallyConsistent", test_MutablePointer_compareExchange_relaxed_sequentiallyConsistent), + ("test_MutablePointer_compareExchange_releasing", test_MutablePointer_compareExchange_releasing), + ("test_MutablePointer_compareExchange_releasing_acquiring", test_MutablePointer_compareExchange_releasing_acquiring), + ("test_MutablePointer_compareExchange_releasing_relaxed", test_MutablePointer_compareExchange_releasing_relaxed), + ("test_MutablePointer_compareExchange_releasing_sequentiallyConsistent", test_MutablePointer_compareExchange_releasing_sequentiallyConsistent), + ("test_MutablePointer_compareExchange_sequentiallyConsistent", test_MutablePointer_compareExchange_sequentiallyConsistent), + ("test_MutablePointer_compareExchange_sequentiallyConsistent_acquiring", test_MutablePointer_compareExchange_sequentiallyConsistent_acquiring), + ("test_MutablePointer_compareExchange_sequentiallyConsistent_relaxed", test_MutablePointer_compareExchange_sequentiallyConsistent_relaxed), + ("test_MutablePointer_compareExchange_sequentiallyConsistent_sequentiallyConsistent", test_MutablePointer_compareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_MutablePointer_create_destroy", test_MutablePointer_create_destroy), + ("test_MutablePointer_exchange_acquiring", test_MutablePointer_exchange_acquiring), + ("test_MutablePointer_exchange_acquiringAndReleasing", test_MutablePointer_exchange_acquiringAndReleasing), + ("test_MutablePointer_exchange_relaxed", test_MutablePointer_exchange_relaxed), + ("test_MutablePointer_exchange_releasing", test_MutablePointer_exchange_releasing), + ("test_MutablePointer_exchange_sequentiallyConsistent", test_MutablePointer_exchange_sequentiallyConsistent), + ("test_MutablePointer_load_acquiring", test_MutablePointer_load_acquiring), + ("test_MutablePointer_load_relaxed", test_MutablePointer_load_relaxed), + ("test_MutablePointer_load_sequentiallyConsistent", test_MutablePointer_load_sequentiallyConsistent), + ("test_MutablePointer_store_relaxed", test_MutablePointer_store_relaxed), + ("test_MutablePointer_store_releasing", test_MutablePointer_store_releasing), + ("test_MutablePointer_store_sequentiallyConsistent", test_MutablePointer_store_sequentiallyConsistent), + ("test_MutablePointer_weakCompareExchange_acquiring_acquiring", test_MutablePointer_weakCompareExchange_acquiring_acquiring), + ("test_MutablePointer_weakCompareExchange_acquiring_relaxed", test_MutablePointer_weakCompareExchange_acquiring_relaxed), + ("test_MutablePointer_weakCompareExchange_acquiring_sequentiallyConsistent", test_MutablePointer_weakCompareExchange_acquiring_sequentiallyConsistent), + ("test_MutablePointer_weakCompareExchange_acquiringAndReleasing_acquiring", test_MutablePointer_weakCompareExchange_acquiringAndReleasing_acquiring), + ("test_MutablePointer_weakCompareExchange_acquiringAndReleasing_relaxed", test_MutablePointer_weakCompareExchange_acquiringAndReleasing_relaxed), + ("test_MutablePointer_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent", test_MutablePointer_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_MutablePointer_weakCompareExchange_relaxed_acquiring", test_MutablePointer_weakCompareExchange_relaxed_acquiring), + ("test_MutablePointer_weakCompareExchange_relaxed_relaxed", test_MutablePointer_weakCompareExchange_relaxed_relaxed), + ("test_MutablePointer_weakCompareExchange_relaxed_sequentiallyConsistent", test_MutablePointer_weakCompareExchange_relaxed_sequentiallyConsistent), + ("test_MutablePointer_weakCompareExchange_releasing_acquiring", test_MutablePointer_weakCompareExchange_releasing_acquiring), + ("test_MutablePointer_weakCompareExchange_releasing_relaxed", test_MutablePointer_weakCompareExchange_releasing_relaxed), + ("test_MutablePointer_weakCompareExchange_releasing_sequentiallyConsistent", test_MutablePointer_weakCompareExchange_releasing_sequentiallyConsistent), + ("test_MutablePointer_weakCompareExchange_sequentiallyConsistent_acquiring", test_MutablePointer_weakCompareExchange_sequentiallyConsistent_acquiring), + ("test_MutablePointer_weakCompareExchange_sequentiallyConsistent_relaxed", test_MutablePointer_weakCompareExchange_sequentiallyConsistent_relaxed), + ("test_MutablePointer_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent", test_MutablePointer_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_OptionalMutablePointer_compareExchange_acquiring", test_OptionalMutablePointer_compareExchange_acquiring), + ("test_OptionalMutablePointer_compareExchange_acquiring_acquiring", test_OptionalMutablePointer_compareExchange_acquiring_acquiring), + ("test_OptionalMutablePointer_compareExchange_acquiring_relaxed", test_OptionalMutablePointer_compareExchange_acquiring_relaxed), + ("test_OptionalMutablePointer_compareExchange_acquiring_sequentiallyConsistent", test_OptionalMutablePointer_compareExchange_acquiring_sequentiallyConsistent), + ("test_OptionalMutablePointer_compareExchange_acquiringAndReleasing", test_OptionalMutablePointer_compareExchange_acquiringAndReleasing), + ("test_OptionalMutablePointer_compareExchange_acquiringAndReleasing_acquiring", test_OptionalMutablePointer_compareExchange_acquiringAndReleasing_acquiring), + ("test_OptionalMutablePointer_compareExchange_acquiringAndReleasing_relaxed", test_OptionalMutablePointer_compareExchange_acquiringAndReleasing_relaxed), + ("test_OptionalMutablePointer_compareExchange_acquiringAndReleasing_sequentiallyConsistent", test_OptionalMutablePointer_compareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_OptionalMutablePointer_compareExchange_relaxed", test_OptionalMutablePointer_compareExchange_relaxed), + ("test_OptionalMutablePointer_compareExchange_relaxed_acquiring", test_OptionalMutablePointer_compareExchange_relaxed_acquiring), + ("test_OptionalMutablePointer_compareExchange_relaxed_relaxed", test_OptionalMutablePointer_compareExchange_relaxed_relaxed), + ("test_OptionalMutablePointer_compareExchange_relaxed_sequentiallyConsistent", test_OptionalMutablePointer_compareExchange_relaxed_sequentiallyConsistent), + ("test_OptionalMutablePointer_compareExchange_releasing", test_OptionalMutablePointer_compareExchange_releasing), + ("test_OptionalMutablePointer_compareExchange_releasing_acquiring", test_OptionalMutablePointer_compareExchange_releasing_acquiring), + ("test_OptionalMutablePointer_compareExchange_releasing_relaxed", test_OptionalMutablePointer_compareExchange_releasing_relaxed), + ("test_OptionalMutablePointer_compareExchange_releasing_sequentiallyConsistent", test_OptionalMutablePointer_compareExchange_releasing_sequentiallyConsistent), + ("test_OptionalMutablePointer_compareExchange_sequentiallyConsistent", test_OptionalMutablePointer_compareExchange_sequentiallyConsistent), + ("test_OptionalMutablePointer_compareExchange_sequentiallyConsistent_acquiring", test_OptionalMutablePointer_compareExchange_sequentiallyConsistent_acquiring), + ("test_OptionalMutablePointer_compareExchange_sequentiallyConsistent_relaxed", test_OptionalMutablePointer_compareExchange_sequentiallyConsistent_relaxed), + ("test_OptionalMutablePointer_compareExchange_sequentiallyConsistent_sequentiallyConsistent", test_OptionalMutablePointer_compareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_OptionalMutablePointer_create_destroy", test_OptionalMutablePointer_create_destroy), + ("test_OptionalMutablePointer_exchange_acquiring", test_OptionalMutablePointer_exchange_acquiring), + ("test_OptionalMutablePointer_exchange_acquiringAndReleasing", test_OptionalMutablePointer_exchange_acquiringAndReleasing), + ("test_OptionalMutablePointer_exchange_relaxed", test_OptionalMutablePointer_exchange_relaxed), + ("test_OptionalMutablePointer_exchange_releasing", test_OptionalMutablePointer_exchange_releasing), + ("test_OptionalMutablePointer_exchange_sequentiallyConsistent", test_OptionalMutablePointer_exchange_sequentiallyConsistent), + ("test_OptionalMutablePointer_load_acquiring", test_OptionalMutablePointer_load_acquiring), + ("test_OptionalMutablePointer_load_relaxed", test_OptionalMutablePointer_load_relaxed), + ("test_OptionalMutablePointer_load_sequentiallyConsistent", test_OptionalMutablePointer_load_sequentiallyConsistent), + ("test_OptionalMutablePointer_store_relaxed", test_OptionalMutablePointer_store_relaxed), + ("test_OptionalMutablePointer_store_releasing", test_OptionalMutablePointer_store_releasing), + ("test_OptionalMutablePointer_store_sequentiallyConsistent", test_OptionalMutablePointer_store_sequentiallyConsistent), + ("test_OptionalMutablePointer_weakCompareExchange_acquiring_acquiring", test_OptionalMutablePointer_weakCompareExchange_acquiring_acquiring), + ("test_OptionalMutablePointer_weakCompareExchange_acquiring_relaxed", test_OptionalMutablePointer_weakCompareExchange_acquiring_relaxed), + ("test_OptionalMutablePointer_weakCompareExchange_acquiring_sequentiallyConsistent", test_OptionalMutablePointer_weakCompareExchange_acquiring_sequentiallyConsistent), + ("test_OptionalMutablePointer_weakCompareExchange_acquiringAndReleasing_acquiring", test_OptionalMutablePointer_weakCompareExchange_acquiringAndReleasing_acquiring), + ("test_OptionalMutablePointer_weakCompareExchange_acquiringAndReleasing_relaxed", test_OptionalMutablePointer_weakCompareExchange_acquiringAndReleasing_relaxed), + ("test_OptionalMutablePointer_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent", test_OptionalMutablePointer_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_OptionalMutablePointer_weakCompareExchange_relaxed_acquiring", test_OptionalMutablePointer_weakCompareExchange_relaxed_acquiring), + ("test_OptionalMutablePointer_weakCompareExchange_relaxed_relaxed", test_OptionalMutablePointer_weakCompareExchange_relaxed_relaxed), + ("test_OptionalMutablePointer_weakCompareExchange_relaxed_sequentiallyConsistent", test_OptionalMutablePointer_weakCompareExchange_relaxed_sequentiallyConsistent), + ("test_OptionalMutablePointer_weakCompareExchange_releasing_acquiring", test_OptionalMutablePointer_weakCompareExchange_releasing_acquiring), + ("test_OptionalMutablePointer_weakCompareExchange_releasing_relaxed", test_OptionalMutablePointer_weakCompareExchange_releasing_relaxed), + ("test_OptionalMutablePointer_weakCompareExchange_releasing_sequentiallyConsistent", test_OptionalMutablePointer_weakCompareExchange_releasing_sequentiallyConsistent), + ("test_OptionalMutablePointer_weakCompareExchange_sequentiallyConsistent_acquiring", test_OptionalMutablePointer_weakCompareExchange_sequentiallyConsistent_acquiring), + ("test_OptionalMutablePointer_weakCompareExchange_sequentiallyConsistent_relaxed", test_OptionalMutablePointer_weakCompareExchange_sequentiallyConsistent_relaxed), + ("test_OptionalMutablePointer_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent", test_OptionalMutablePointer_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_OptionalPointer_compareExchange_acquiring", test_OptionalPointer_compareExchange_acquiring), + ("test_OptionalPointer_compareExchange_acquiring_acquiring", test_OptionalPointer_compareExchange_acquiring_acquiring), + ("test_OptionalPointer_compareExchange_acquiring_relaxed", test_OptionalPointer_compareExchange_acquiring_relaxed), + ("test_OptionalPointer_compareExchange_acquiring_sequentiallyConsistent", test_OptionalPointer_compareExchange_acquiring_sequentiallyConsistent), + ("test_OptionalPointer_compareExchange_acquiringAndReleasing", test_OptionalPointer_compareExchange_acquiringAndReleasing), + ("test_OptionalPointer_compareExchange_acquiringAndReleasing_acquiring", test_OptionalPointer_compareExchange_acquiringAndReleasing_acquiring), + ("test_OptionalPointer_compareExchange_acquiringAndReleasing_relaxed", test_OptionalPointer_compareExchange_acquiringAndReleasing_relaxed), + ("test_OptionalPointer_compareExchange_acquiringAndReleasing_sequentiallyConsistent", test_OptionalPointer_compareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_OptionalPointer_compareExchange_relaxed", test_OptionalPointer_compareExchange_relaxed), + ("test_OptionalPointer_compareExchange_relaxed_acquiring", test_OptionalPointer_compareExchange_relaxed_acquiring), + ("test_OptionalPointer_compareExchange_relaxed_relaxed", test_OptionalPointer_compareExchange_relaxed_relaxed), + ("test_OptionalPointer_compareExchange_relaxed_sequentiallyConsistent", test_OptionalPointer_compareExchange_relaxed_sequentiallyConsistent), + ("test_OptionalPointer_compareExchange_releasing", test_OptionalPointer_compareExchange_releasing), + ("test_OptionalPointer_compareExchange_releasing_acquiring", test_OptionalPointer_compareExchange_releasing_acquiring), + ("test_OptionalPointer_compareExchange_releasing_relaxed", test_OptionalPointer_compareExchange_releasing_relaxed), + ("test_OptionalPointer_compareExchange_releasing_sequentiallyConsistent", test_OptionalPointer_compareExchange_releasing_sequentiallyConsistent), + ("test_OptionalPointer_compareExchange_sequentiallyConsistent", test_OptionalPointer_compareExchange_sequentiallyConsistent), + ("test_OptionalPointer_compareExchange_sequentiallyConsistent_acquiring", test_OptionalPointer_compareExchange_sequentiallyConsistent_acquiring), + ("test_OptionalPointer_compareExchange_sequentiallyConsistent_relaxed", test_OptionalPointer_compareExchange_sequentiallyConsistent_relaxed), + ("test_OptionalPointer_compareExchange_sequentiallyConsistent_sequentiallyConsistent", test_OptionalPointer_compareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_OptionalPointer_create_destroy", test_OptionalPointer_create_destroy), + ("test_OptionalPointer_exchange_acquiring", test_OptionalPointer_exchange_acquiring), + ("test_OptionalPointer_exchange_acquiringAndReleasing", test_OptionalPointer_exchange_acquiringAndReleasing), + ("test_OptionalPointer_exchange_relaxed", test_OptionalPointer_exchange_relaxed), + ("test_OptionalPointer_exchange_releasing", test_OptionalPointer_exchange_releasing), + ("test_OptionalPointer_exchange_sequentiallyConsistent", test_OptionalPointer_exchange_sequentiallyConsistent), + ("test_OptionalPointer_load_acquiring", test_OptionalPointer_load_acquiring), + ("test_OptionalPointer_load_relaxed", test_OptionalPointer_load_relaxed), + ("test_OptionalPointer_load_sequentiallyConsistent", test_OptionalPointer_load_sequentiallyConsistent), + ("test_OptionalPointer_store_relaxed", test_OptionalPointer_store_relaxed), + ("test_OptionalPointer_store_releasing", test_OptionalPointer_store_releasing), + ("test_OptionalPointer_store_sequentiallyConsistent", test_OptionalPointer_store_sequentiallyConsistent), + ("test_OptionalPointer_weakCompareExchange_acquiring_acquiring", test_OptionalPointer_weakCompareExchange_acquiring_acquiring), + ("test_OptionalPointer_weakCompareExchange_acquiring_relaxed", test_OptionalPointer_weakCompareExchange_acquiring_relaxed), + ("test_OptionalPointer_weakCompareExchange_acquiring_sequentiallyConsistent", test_OptionalPointer_weakCompareExchange_acquiring_sequentiallyConsistent), + ("test_OptionalPointer_weakCompareExchange_acquiringAndReleasing_acquiring", test_OptionalPointer_weakCompareExchange_acquiringAndReleasing_acquiring), + ("test_OptionalPointer_weakCompareExchange_acquiringAndReleasing_relaxed", test_OptionalPointer_weakCompareExchange_acquiringAndReleasing_relaxed), + ("test_OptionalPointer_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent", test_OptionalPointer_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_OptionalPointer_weakCompareExchange_relaxed_acquiring", test_OptionalPointer_weakCompareExchange_relaxed_acquiring), + ("test_OptionalPointer_weakCompareExchange_relaxed_relaxed", test_OptionalPointer_weakCompareExchange_relaxed_relaxed), + ("test_OptionalPointer_weakCompareExchange_relaxed_sequentiallyConsistent", test_OptionalPointer_weakCompareExchange_relaxed_sequentiallyConsistent), + ("test_OptionalPointer_weakCompareExchange_releasing_acquiring", test_OptionalPointer_weakCompareExchange_releasing_acquiring), + ("test_OptionalPointer_weakCompareExchange_releasing_relaxed", test_OptionalPointer_weakCompareExchange_releasing_relaxed), + ("test_OptionalPointer_weakCompareExchange_releasing_sequentiallyConsistent", test_OptionalPointer_weakCompareExchange_releasing_sequentiallyConsistent), + ("test_OptionalPointer_weakCompareExchange_sequentiallyConsistent_acquiring", test_OptionalPointer_weakCompareExchange_sequentiallyConsistent_acquiring), + ("test_OptionalPointer_weakCompareExchange_sequentiallyConsistent_relaxed", test_OptionalPointer_weakCompareExchange_sequentiallyConsistent_relaxed), + ("test_OptionalPointer_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent", test_OptionalPointer_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_OptionalRawPointer_compareExchange_acquiring", test_OptionalRawPointer_compareExchange_acquiring), + ("test_OptionalRawPointer_compareExchange_acquiring_acquiring", test_OptionalRawPointer_compareExchange_acquiring_acquiring), + ("test_OptionalRawPointer_compareExchange_acquiring_relaxed", test_OptionalRawPointer_compareExchange_acquiring_relaxed), + ("test_OptionalRawPointer_compareExchange_acquiring_sequentiallyConsistent", test_OptionalRawPointer_compareExchange_acquiring_sequentiallyConsistent), + ("test_OptionalRawPointer_compareExchange_acquiringAndReleasing", test_OptionalRawPointer_compareExchange_acquiringAndReleasing), + ("test_OptionalRawPointer_compareExchange_acquiringAndReleasing_acquiring", test_OptionalRawPointer_compareExchange_acquiringAndReleasing_acquiring), + ("test_OptionalRawPointer_compareExchange_acquiringAndReleasing_relaxed", test_OptionalRawPointer_compareExchange_acquiringAndReleasing_relaxed), + ("test_OptionalRawPointer_compareExchange_acquiringAndReleasing_sequentiallyConsistent", test_OptionalRawPointer_compareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_OptionalRawPointer_compareExchange_relaxed", test_OptionalRawPointer_compareExchange_relaxed), + ("test_OptionalRawPointer_compareExchange_relaxed_acquiring", test_OptionalRawPointer_compareExchange_relaxed_acquiring), + ("test_OptionalRawPointer_compareExchange_relaxed_relaxed", test_OptionalRawPointer_compareExchange_relaxed_relaxed), + ("test_OptionalRawPointer_compareExchange_relaxed_sequentiallyConsistent", test_OptionalRawPointer_compareExchange_relaxed_sequentiallyConsistent), + ("test_OptionalRawPointer_compareExchange_releasing", test_OptionalRawPointer_compareExchange_releasing), + ("test_OptionalRawPointer_compareExchange_releasing_acquiring", test_OptionalRawPointer_compareExchange_releasing_acquiring), + ("test_OptionalRawPointer_compareExchange_releasing_relaxed", test_OptionalRawPointer_compareExchange_releasing_relaxed), + ("test_OptionalRawPointer_compareExchange_releasing_sequentiallyConsistent", test_OptionalRawPointer_compareExchange_releasing_sequentiallyConsistent), + ("test_OptionalRawPointer_compareExchange_sequentiallyConsistent", test_OptionalRawPointer_compareExchange_sequentiallyConsistent), + ("test_OptionalRawPointer_compareExchange_sequentiallyConsistent_acquiring", test_OptionalRawPointer_compareExchange_sequentiallyConsistent_acquiring), + ("test_OptionalRawPointer_compareExchange_sequentiallyConsistent_relaxed", test_OptionalRawPointer_compareExchange_sequentiallyConsistent_relaxed), + ("test_OptionalRawPointer_compareExchange_sequentiallyConsistent_sequentiallyConsistent", test_OptionalRawPointer_compareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_OptionalRawPointer_create_destroy", test_OptionalRawPointer_create_destroy), + ("test_OptionalRawPointer_exchange_acquiring", test_OptionalRawPointer_exchange_acquiring), + ("test_OptionalRawPointer_exchange_acquiringAndReleasing", test_OptionalRawPointer_exchange_acquiringAndReleasing), + ("test_OptionalRawPointer_exchange_relaxed", test_OptionalRawPointer_exchange_relaxed), + ("test_OptionalRawPointer_exchange_releasing", test_OptionalRawPointer_exchange_releasing), + ("test_OptionalRawPointer_exchange_sequentiallyConsistent", test_OptionalRawPointer_exchange_sequentiallyConsistent), + ("test_OptionalRawPointer_load_acquiring", test_OptionalRawPointer_load_acquiring), + ("test_OptionalRawPointer_load_relaxed", test_OptionalRawPointer_load_relaxed), + ("test_OptionalRawPointer_load_sequentiallyConsistent", test_OptionalRawPointer_load_sequentiallyConsistent), + ("test_OptionalRawPointer_store_relaxed", test_OptionalRawPointer_store_relaxed), + ("test_OptionalRawPointer_store_releasing", test_OptionalRawPointer_store_releasing), + ("test_OptionalRawPointer_store_sequentiallyConsistent", test_OptionalRawPointer_store_sequentiallyConsistent), + ("test_OptionalRawPointer_weakCompareExchange_acquiring_acquiring", test_OptionalRawPointer_weakCompareExchange_acquiring_acquiring), + ("test_OptionalRawPointer_weakCompareExchange_acquiring_relaxed", test_OptionalRawPointer_weakCompareExchange_acquiring_relaxed), + ("test_OptionalRawPointer_weakCompareExchange_acquiring_sequentiallyConsistent", test_OptionalRawPointer_weakCompareExchange_acquiring_sequentiallyConsistent), + ("test_OptionalRawPointer_weakCompareExchange_acquiringAndReleasing_acquiring", test_OptionalRawPointer_weakCompareExchange_acquiringAndReleasing_acquiring), + ("test_OptionalRawPointer_weakCompareExchange_acquiringAndReleasing_relaxed", test_OptionalRawPointer_weakCompareExchange_acquiringAndReleasing_relaxed), + ("test_OptionalRawPointer_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent", test_OptionalRawPointer_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_OptionalRawPointer_weakCompareExchange_relaxed_acquiring", test_OptionalRawPointer_weakCompareExchange_relaxed_acquiring), + ("test_OptionalRawPointer_weakCompareExchange_relaxed_relaxed", test_OptionalRawPointer_weakCompareExchange_relaxed_relaxed), + ("test_OptionalRawPointer_weakCompareExchange_relaxed_sequentiallyConsistent", test_OptionalRawPointer_weakCompareExchange_relaxed_sequentiallyConsistent), + ("test_OptionalRawPointer_weakCompareExchange_releasing_acquiring", test_OptionalRawPointer_weakCompareExchange_releasing_acquiring), + ("test_OptionalRawPointer_weakCompareExchange_releasing_relaxed", test_OptionalRawPointer_weakCompareExchange_releasing_relaxed), + ("test_OptionalRawPointer_weakCompareExchange_releasing_sequentiallyConsistent", test_OptionalRawPointer_weakCompareExchange_releasing_sequentiallyConsistent), + ("test_OptionalRawPointer_weakCompareExchange_sequentiallyConsistent_acquiring", test_OptionalRawPointer_weakCompareExchange_sequentiallyConsistent_acquiring), + ("test_OptionalRawPointer_weakCompareExchange_sequentiallyConsistent_relaxed", test_OptionalRawPointer_weakCompareExchange_sequentiallyConsistent_relaxed), + ("test_OptionalRawPointer_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent", test_OptionalRawPointer_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_OptionalReference_compareExchange_acquiring", test_OptionalReference_compareExchange_acquiring), + ("test_OptionalReference_compareExchange_acquiring_acquiring", test_OptionalReference_compareExchange_acquiring_acquiring), + ("test_OptionalReference_compareExchange_acquiring_relaxed", test_OptionalReference_compareExchange_acquiring_relaxed), + ("test_OptionalReference_compareExchange_acquiring_sequentiallyConsistent", test_OptionalReference_compareExchange_acquiring_sequentiallyConsistent), + ("test_OptionalReference_compareExchange_acquiringAndReleasing", test_OptionalReference_compareExchange_acquiringAndReleasing), + ("test_OptionalReference_compareExchange_acquiringAndReleasing_acquiring", test_OptionalReference_compareExchange_acquiringAndReleasing_acquiring), + ("test_OptionalReference_compareExchange_acquiringAndReleasing_relaxed", test_OptionalReference_compareExchange_acquiringAndReleasing_relaxed), + ("test_OptionalReference_compareExchange_acquiringAndReleasing_sequentiallyConsistent", test_OptionalReference_compareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_OptionalReference_compareExchange_relaxed", test_OptionalReference_compareExchange_relaxed), + ("test_OptionalReference_compareExchange_relaxed_acquiring", test_OptionalReference_compareExchange_relaxed_acquiring), + ("test_OptionalReference_compareExchange_relaxed_relaxed", test_OptionalReference_compareExchange_relaxed_relaxed), + ("test_OptionalReference_compareExchange_relaxed_sequentiallyConsistent", test_OptionalReference_compareExchange_relaxed_sequentiallyConsistent), + ("test_OptionalReference_compareExchange_releasing", test_OptionalReference_compareExchange_releasing), + ("test_OptionalReference_compareExchange_releasing_acquiring", test_OptionalReference_compareExchange_releasing_acquiring), + ("test_OptionalReference_compareExchange_releasing_relaxed", test_OptionalReference_compareExchange_releasing_relaxed), + ("test_OptionalReference_compareExchange_releasing_sequentiallyConsistent", test_OptionalReference_compareExchange_releasing_sequentiallyConsistent), + ("test_OptionalReference_compareExchange_sequentiallyConsistent", test_OptionalReference_compareExchange_sequentiallyConsistent), + ("test_OptionalReference_compareExchange_sequentiallyConsistent_acquiring", test_OptionalReference_compareExchange_sequentiallyConsistent_acquiring), + ("test_OptionalReference_compareExchange_sequentiallyConsistent_relaxed", test_OptionalReference_compareExchange_sequentiallyConsistent_relaxed), + ("test_OptionalReference_compareExchange_sequentiallyConsistent_sequentiallyConsistent", test_OptionalReference_compareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_OptionalReference_create_destroy", test_OptionalReference_create_destroy), + ("test_OptionalReference_exchange_acquiring", test_OptionalReference_exchange_acquiring), + ("test_OptionalReference_exchange_acquiringAndReleasing", test_OptionalReference_exchange_acquiringAndReleasing), + ("test_OptionalReference_exchange_relaxed", test_OptionalReference_exchange_relaxed), + ("test_OptionalReference_exchange_releasing", test_OptionalReference_exchange_releasing), + ("test_OptionalReference_exchange_sequentiallyConsistent", test_OptionalReference_exchange_sequentiallyConsistent), + ("test_OptionalReference_load_acquiring", test_OptionalReference_load_acquiring), + ("test_OptionalReference_load_relaxed", test_OptionalReference_load_relaxed), + ("test_OptionalReference_load_sequentiallyConsistent", test_OptionalReference_load_sequentiallyConsistent), + ("test_OptionalReference_store_relaxed", test_OptionalReference_store_relaxed), + ("test_OptionalReference_store_releasing", test_OptionalReference_store_releasing), + ("test_OptionalReference_store_sequentiallyConsistent", test_OptionalReference_store_sequentiallyConsistent), + ("test_OptionalReference_weakCompareExchange_acquiring_acquiring", test_OptionalReference_weakCompareExchange_acquiring_acquiring), + ("test_OptionalReference_weakCompareExchange_acquiring_relaxed", test_OptionalReference_weakCompareExchange_acquiring_relaxed), + ("test_OptionalReference_weakCompareExchange_acquiring_sequentiallyConsistent", test_OptionalReference_weakCompareExchange_acquiring_sequentiallyConsistent), + ("test_OptionalReference_weakCompareExchange_acquiringAndReleasing_acquiring", test_OptionalReference_weakCompareExchange_acquiringAndReleasing_acquiring), + ("test_OptionalReference_weakCompareExchange_acquiringAndReleasing_relaxed", test_OptionalReference_weakCompareExchange_acquiringAndReleasing_relaxed), + ("test_OptionalReference_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent", test_OptionalReference_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_OptionalReference_weakCompareExchange_relaxed_acquiring", test_OptionalReference_weakCompareExchange_relaxed_acquiring), + ("test_OptionalReference_weakCompareExchange_relaxed_relaxed", test_OptionalReference_weakCompareExchange_relaxed_relaxed), + ("test_OptionalReference_weakCompareExchange_relaxed_sequentiallyConsistent", test_OptionalReference_weakCompareExchange_relaxed_sequentiallyConsistent), + ("test_OptionalReference_weakCompareExchange_releasing_acquiring", test_OptionalReference_weakCompareExchange_releasing_acquiring), + ("test_OptionalReference_weakCompareExchange_releasing_relaxed", test_OptionalReference_weakCompareExchange_releasing_relaxed), + ("test_OptionalReference_weakCompareExchange_releasing_sequentiallyConsistent", test_OptionalReference_weakCompareExchange_releasing_sequentiallyConsistent), + ("test_OptionalReference_weakCompareExchange_sequentiallyConsistent_acquiring", test_OptionalReference_weakCompareExchange_sequentiallyConsistent_acquiring), + ("test_OptionalReference_weakCompareExchange_sequentiallyConsistent_relaxed", test_OptionalReference_weakCompareExchange_sequentiallyConsistent_relaxed), + ("test_OptionalReference_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent", test_OptionalReference_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_OptionalUnmanaged_compareExchange_acquiring", test_OptionalUnmanaged_compareExchange_acquiring), + ("test_OptionalUnmanaged_compareExchange_acquiring_acquiring", test_OptionalUnmanaged_compareExchange_acquiring_acquiring), + ("test_OptionalUnmanaged_compareExchange_acquiring_relaxed", test_OptionalUnmanaged_compareExchange_acquiring_relaxed), + ("test_OptionalUnmanaged_compareExchange_acquiring_sequentiallyConsistent", test_OptionalUnmanaged_compareExchange_acquiring_sequentiallyConsistent), + ("test_OptionalUnmanaged_compareExchange_acquiringAndReleasing", test_OptionalUnmanaged_compareExchange_acquiringAndReleasing), + ("test_OptionalUnmanaged_compareExchange_acquiringAndReleasing_acquiring", test_OptionalUnmanaged_compareExchange_acquiringAndReleasing_acquiring), + ("test_OptionalUnmanaged_compareExchange_acquiringAndReleasing_relaxed", test_OptionalUnmanaged_compareExchange_acquiringAndReleasing_relaxed), + ("test_OptionalUnmanaged_compareExchange_acquiringAndReleasing_sequentiallyConsistent", test_OptionalUnmanaged_compareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_OptionalUnmanaged_compareExchange_relaxed", test_OptionalUnmanaged_compareExchange_relaxed), + ("test_OptionalUnmanaged_compareExchange_relaxed_acquiring", test_OptionalUnmanaged_compareExchange_relaxed_acquiring), + ("test_OptionalUnmanaged_compareExchange_relaxed_relaxed", test_OptionalUnmanaged_compareExchange_relaxed_relaxed), + ("test_OptionalUnmanaged_compareExchange_relaxed_sequentiallyConsistent", test_OptionalUnmanaged_compareExchange_relaxed_sequentiallyConsistent), + ("test_OptionalUnmanaged_compareExchange_releasing", test_OptionalUnmanaged_compareExchange_releasing), + ("test_OptionalUnmanaged_compareExchange_releasing_acquiring", test_OptionalUnmanaged_compareExchange_releasing_acquiring), + ("test_OptionalUnmanaged_compareExchange_releasing_relaxed", test_OptionalUnmanaged_compareExchange_releasing_relaxed), + ("test_OptionalUnmanaged_compareExchange_releasing_sequentiallyConsistent", test_OptionalUnmanaged_compareExchange_releasing_sequentiallyConsistent), + ("test_OptionalUnmanaged_compareExchange_sequentiallyConsistent", test_OptionalUnmanaged_compareExchange_sequentiallyConsistent), + ("test_OptionalUnmanaged_compareExchange_sequentiallyConsistent_acquiring", test_OptionalUnmanaged_compareExchange_sequentiallyConsistent_acquiring), + ("test_OptionalUnmanaged_compareExchange_sequentiallyConsistent_relaxed", test_OptionalUnmanaged_compareExchange_sequentiallyConsistent_relaxed), + ("test_OptionalUnmanaged_compareExchange_sequentiallyConsistent_sequentiallyConsistent", test_OptionalUnmanaged_compareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_OptionalUnmanaged_create_destroy", test_OptionalUnmanaged_create_destroy), + ("test_OptionalUnmanaged_exchange_acquiring", test_OptionalUnmanaged_exchange_acquiring), + ("test_OptionalUnmanaged_exchange_acquiringAndReleasing", test_OptionalUnmanaged_exchange_acquiringAndReleasing), + ("test_OptionalUnmanaged_exchange_relaxed", test_OptionalUnmanaged_exchange_relaxed), + ("test_OptionalUnmanaged_exchange_releasing", test_OptionalUnmanaged_exchange_releasing), + ("test_OptionalUnmanaged_exchange_sequentiallyConsistent", test_OptionalUnmanaged_exchange_sequentiallyConsistent), + ("test_OptionalUnmanaged_load_acquiring", test_OptionalUnmanaged_load_acquiring), + ("test_OptionalUnmanaged_load_relaxed", test_OptionalUnmanaged_load_relaxed), + ("test_OptionalUnmanaged_load_sequentiallyConsistent", test_OptionalUnmanaged_load_sequentiallyConsistent), + ("test_OptionalUnmanaged_store_relaxed", test_OptionalUnmanaged_store_relaxed), + ("test_OptionalUnmanaged_store_releasing", test_OptionalUnmanaged_store_releasing), + ("test_OptionalUnmanaged_store_sequentiallyConsistent", test_OptionalUnmanaged_store_sequentiallyConsistent), + ("test_OptionalUnmanaged_weakCompareExchange_acquiring_acquiring", test_OptionalUnmanaged_weakCompareExchange_acquiring_acquiring), + ("test_OptionalUnmanaged_weakCompareExchange_acquiring_relaxed", test_OptionalUnmanaged_weakCompareExchange_acquiring_relaxed), + ("test_OptionalUnmanaged_weakCompareExchange_acquiring_sequentiallyConsistent", test_OptionalUnmanaged_weakCompareExchange_acquiring_sequentiallyConsistent), + ("test_OptionalUnmanaged_weakCompareExchange_acquiringAndReleasing_acquiring", test_OptionalUnmanaged_weakCompareExchange_acquiringAndReleasing_acquiring), + ("test_OptionalUnmanaged_weakCompareExchange_acquiringAndReleasing_relaxed", test_OptionalUnmanaged_weakCompareExchange_acquiringAndReleasing_relaxed), + ("test_OptionalUnmanaged_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent", test_OptionalUnmanaged_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_OptionalUnmanaged_weakCompareExchange_relaxed_acquiring", test_OptionalUnmanaged_weakCompareExchange_relaxed_acquiring), + ("test_OptionalUnmanaged_weakCompareExchange_relaxed_relaxed", test_OptionalUnmanaged_weakCompareExchange_relaxed_relaxed), + ("test_OptionalUnmanaged_weakCompareExchange_relaxed_sequentiallyConsistent", test_OptionalUnmanaged_weakCompareExchange_relaxed_sequentiallyConsistent), + ("test_OptionalUnmanaged_weakCompareExchange_releasing_acquiring", test_OptionalUnmanaged_weakCompareExchange_releasing_acquiring), + ("test_OptionalUnmanaged_weakCompareExchange_releasing_relaxed", test_OptionalUnmanaged_weakCompareExchange_releasing_relaxed), + ("test_OptionalUnmanaged_weakCompareExchange_releasing_sequentiallyConsistent", test_OptionalUnmanaged_weakCompareExchange_releasing_sequentiallyConsistent), + ("test_OptionalUnmanaged_weakCompareExchange_sequentiallyConsistent_acquiring", test_OptionalUnmanaged_weakCompareExchange_sequentiallyConsistent_acquiring), + ("test_OptionalUnmanaged_weakCompareExchange_sequentiallyConsistent_relaxed", test_OptionalUnmanaged_weakCompareExchange_sequentiallyConsistent_relaxed), + ("test_OptionalUnmanaged_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent", test_OptionalUnmanaged_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_Pointer_compareExchange_acquiring", test_Pointer_compareExchange_acquiring), + ("test_Pointer_compareExchange_acquiring_acquiring", test_Pointer_compareExchange_acquiring_acquiring), + ("test_Pointer_compareExchange_acquiring_relaxed", test_Pointer_compareExchange_acquiring_relaxed), + ("test_Pointer_compareExchange_acquiring_sequentiallyConsistent", test_Pointer_compareExchange_acquiring_sequentiallyConsistent), + ("test_Pointer_compareExchange_acquiringAndReleasing", test_Pointer_compareExchange_acquiringAndReleasing), + ("test_Pointer_compareExchange_acquiringAndReleasing_acquiring", test_Pointer_compareExchange_acquiringAndReleasing_acquiring), + ("test_Pointer_compareExchange_acquiringAndReleasing_relaxed", test_Pointer_compareExchange_acquiringAndReleasing_relaxed), + ("test_Pointer_compareExchange_acquiringAndReleasing_sequentiallyConsistent", test_Pointer_compareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_Pointer_compareExchange_relaxed", test_Pointer_compareExchange_relaxed), + ("test_Pointer_compareExchange_relaxed_acquiring", test_Pointer_compareExchange_relaxed_acquiring), + ("test_Pointer_compareExchange_relaxed_relaxed", test_Pointer_compareExchange_relaxed_relaxed), + ("test_Pointer_compareExchange_relaxed_sequentiallyConsistent", test_Pointer_compareExchange_relaxed_sequentiallyConsistent), + ("test_Pointer_compareExchange_releasing", test_Pointer_compareExchange_releasing), + ("test_Pointer_compareExchange_releasing_acquiring", test_Pointer_compareExchange_releasing_acquiring), + ("test_Pointer_compareExchange_releasing_relaxed", test_Pointer_compareExchange_releasing_relaxed), + ("test_Pointer_compareExchange_releasing_sequentiallyConsistent", test_Pointer_compareExchange_releasing_sequentiallyConsistent), + ("test_Pointer_compareExchange_sequentiallyConsistent", test_Pointer_compareExchange_sequentiallyConsistent), + ("test_Pointer_compareExchange_sequentiallyConsistent_acquiring", test_Pointer_compareExchange_sequentiallyConsistent_acquiring), + ("test_Pointer_compareExchange_sequentiallyConsistent_relaxed", test_Pointer_compareExchange_sequentiallyConsistent_relaxed), + ("test_Pointer_compareExchange_sequentiallyConsistent_sequentiallyConsistent", test_Pointer_compareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_Pointer_create_destroy", test_Pointer_create_destroy), + ("test_Pointer_exchange_acquiring", test_Pointer_exchange_acquiring), + ("test_Pointer_exchange_acquiringAndReleasing", test_Pointer_exchange_acquiringAndReleasing), + ("test_Pointer_exchange_relaxed", test_Pointer_exchange_relaxed), + ("test_Pointer_exchange_releasing", test_Pointer_exchange_releasing), + ("test_Pointer_exchange_sequentiallyConsistent", test_Pointer_exchange_sequentiallyConsistent), + ("test_Pointer_load_acquiring", test_Pointer_load_acquiring), + ("test_Pointer_load_relaxed", test_Pointer_load_relaxed), + ("test_Pointer_load_sequentiallyConsistent", test_Pointer_load_sequentiallyConsistent), + ("test_Pointer_store_relaxed", test_Pointer_store_relaxed), + ("test_Pointer_store_releasing", test_Pointer_store_releasing), + ("test_Pointer_store_sequentiallyConsistent", test_Pointer_store_sequentiallyConsistent), + ("test_Pointer_weakCompareExchange_acquiring_acquiring", test_Pointer_weakCompareExchange_acquiring_acquiring), + ("test_Pointer_weakCompareExchange_acquiring_relaxed", test_Pointer_weakCompareExchange_acquiring_relaxed), + ("test_Pointer_weakCompareExchange_acquiring_sequentiallyConsistent", test_Pointer_weakCompareExchange_acquiring_sequentiallyConsistent), + ("test_Pointer_weakCompareExchange_acquiringAndReleasing_acquiring", test_Pointer_weakCompareExchange_acquiringAndReleasing_acquiring), + ("test_Pointer_weakCompareExchange_acquiringAndReleasing_relaxed", test_Pointer_weakCompareExchange_acquiringAndReleasing_relaxed), + ("test_Pointer_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent", test_Pointer_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_Pointer_weakCompareExchange_relaxed_acquiring", test_Pointer_weakCompareExchange_relaxed_acquiring), + ("test_Pointer_weakCompareExchange_relaxed_relaxed", test_Pointer_weakCompareExchange_relaxed_relaxed), + ("test_Pointer_weakCompareExchange_relaxed_sequentiallyConsistent", test_Pointer_weakCompareExchange_relaxed_sequentiallyConsistent), + ("test_Pointer_weakCompareExchange_releasing_acquiring", test_Pointer_weakCompareExchange_releasing_acquiring), + ("test_Pointer_weakCompareExchange_releasing_relaxed", test_Pointer_weakCompareExchange_releasing_relaxed), + ("test_Pointer_weakCompareExchange_releasing_sequentiallyConsistent", test_Pointer_weakCompareExchange_releasing_sequentiallyConsistent), + ("test_Pointer_weakCompareExchange_sequentiallyConsistent_acquiring", test_Pointer_weakCompareExchange_sequentiallyConsistent_acquiring), + ("test_Pointer_weakCompareExchange_sequentiallyConsistent_relaxed", test_Pointer_weakCompareExchange_sequentiallyConsistent_relaxed), + ("test_Pointer_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent", test_Pointer_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_RawPointer_compareExchange_acquiring", test_RawPointer_compareExchange_acquiring), + ("test_RawPointer_compareExchange_acquiring_acquiring", test_RawPointer_compareExchange_acquiring_acquiring), + ("test_RawPointer_compareExchange_acquiring_relaxed", test_RawPointer_compareExchange_acquiring_relaxed), + ("test_RawPointer_compareExchange_acquiring_sequentiallyConsistent", test_RawPointer_compareExchange_acquiring_sequentiallyConsistent), + ("test_RawPointer_compareExchange_acquiringAndReleasing", test_RawPointer_compareExchange_acquiringAndReleasing), + ("test_RawPointer_compareExchange_acquiringAndReleasing_acquiring", test_RawPointer_compareExchange_acquiringAndReleasing_acquiring), + ("test_RawPointer_compareExchange_acquiringAndReleasing_relaxed", test_RawPointer_compareExchange_acquiringAndReleasing_relaxed), + ("test_RawPointer_compareExchange_acquiringAndReleasing_sequentiallyConsistent", test_RawPointer_compareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_RawPointer_compareExchange_relaxed", test_RawPointer_compareExchange_relaxed), + ("test_RawPointer_compareExchange_relaxed_acquiring", test_RawPointer_compareExchange_relaxed_acquiring), + ("test_RawPointer_compareExchange_relaxed_relaxed", test_RawPointer_compareExchange_relaxed_relaxed), + ("test_RawPointer_compareExchange_relaxed_sequentiallyConsistent", test_RawPointer_compareExchange_relaxed_sequentiallyConsistent), + ("test_RawPointer_compareExchange_releasing", test_RawPointer_compareExchange_releasing), + ("test_RawPointer_compareExchange_releasing_acquiring", test_RawPointer_compareExchange_releasing_acquiring), + ("test_RawPointer_compareExchange_releasing_relaxed", test_RawPointer_compareExchange_releasing_relaxed), + ("test_RawPointer_compareExchange_releasing_sequentiallyConsistent", test_RawPointer_compareExchange_releasing_sequentiallyConsistent), + ("test_RawPointer_compareExchange_sequentiallyConsistent", test_RawPointer_compareExchange_sequentiallyConsistent), + ("test_RawPointer_compareExchange_sequentiallyConsistent_acquiring", test_RawPointer_compareExchange_sequentiallyConsistent_acquiring), + ("test_RawPointer_compareExchange_sequentiallyConsistent_relaxed", test_RawPointer_compareExchange_sequentiallyConsistent_relaxed), + ("test_RawPointer_compareExchange_sequentiallyConsistent_sequentiallyConsistent", test_RawPointer_compareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_RawPointer_create_destroy", test_RawPointer_create_destroy), + ("test_RawPointer_exchange_acquiring", test_RawPointer_exchange_acquiring), + ("test_RawPointer_exchange_acquiringAndReleasing", test_RawPointer_exchange_acquiringAndReleasing), + ("test_RawPointer_exchange_relaxed", test_RawPointer_exchange_relaxed), + ("test_RawPointer_exchange_releasing", test_RawPointer_exchange_releasing), + ("test_RawPointer_exchange_sequentiallyConsistent", test_RawPointer_exchange_sequentiallyConsistent), + ("test_RawPointer_load_acquiring", test_RawPointer_load_acquiring), + ("test_RawPointer_load_relaxed", test_RawPointer_load_relaxed), + ("test_RawPointer_load_sequentiallyConsistent", test_RawPointer_load_sequentiallyConsistent), + ("test_RawPointer_store_relaxed", test_RawPointer_store_relaxed), + ("test_RawPointer_store_releasing", test_RawPointer_store_releasing), + ("test_RawPointer_store_sequentiallyConsistent", test_RawPointer_store_sequentiallyConsistent), + ("test_RawPointer_weakCompareExchange_acquiring_acquiring", test_RawPointer_weakCompareExchange_acquiring_acquiring), + ("test_RawPointer_weakCompareExchange_acquiring_relaxed", test_RawPointer_weakCompareExchange_acquiring_relaxed), + ("test_RawPointer_weakCompareExchange_acquiring_sequentiallyConsistent", test_RawPointer_weakCompareExchange_acquiring_sequentiallyConsistent), + ("test_RawPointer_weakCompareExchange_acquiringAndReleasing_acquiring", test_RawPointer_weakCompareExchange_acquiringAndReleasing_acquiring), + ("test_RawPointer_weakCompareExchange_acquiringAndReleasing_relaxed", test_RawPointer_weakCompareExchange_acquiringAndReleasing_relaxed), + ("test_RawPointer_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent", test_RawPointer_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_RawPointer_weakCompareExchange_relaxed_acquiring", test_RawPointer_weakCompareExchange_relaxed_acquiring), + ("test_RawPointer_weakCompareExchange_relaxed_relaxed", test_RawPointer_weakCompareExchange_relaxed_relaxed), + ("test_RawPointer_weakCompareExchange_relaxed_sequentiallyConsistent", test_RawPointer_weakCompareExchange_relaxed_sequentiallyConsistent), + ("test_RawPointer_weakCompareExchange_releasing_acquiring", test_RawPointer_weakCompareExchange_releasing_acquiring), + ("test_RawPointer_weakCompareExchange_releasing_relaxed", test_RawPointer_weakCompareExchange_releasing_relaxed), + ("test_RawPointer_weakCompareExchange_releasing_sequentiallyConsistent", test_RawPointer_weakCompareExchange_releasing_sequentiallyConsistent), + ("test_RawPointer_weakCompareExchange_sequentiallyConsistent_acquiring", test_RawPointer_weakCompareExchange_sequentiallyConsistent_acquiring), + ("test_RawPointer_weakCompareExchange_sequentiallyConsistent_relaxed", test_RawPointer_weakCompareExchange_sequentiallyConsistent_relaxed), + ("test_RawPointer_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent", test_RawPointer_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_RawRepresentable_compareExchange_acquiring", test_RawRepresentable_compareExchange_acquiring), + ("test_RawRepresentable_compareExchange_acquiring_acquiring", test_RawRepresentable_compareExchange_acquiring_acquiring), + ("test_RawRepresentable_compareExchange_acquiring_relaxed", test_RawRepresentable_compareExchange_acquiring_relaxed), + ("test_RawRepresentable_compareExchange_acquiring_sequentiallyConsistent", test_RawRepresentable_compareExchange_acquiring_sequentiallyConsistent), + ("test_RawRepresentable_compareExchange_acquiringAndReleasing", test_RawRepresentable_compareExchange_acquiringAndReleasing), + ("test_RawRepresentable_compareExchange_acquiringAndReleasing_acquiring", test_RawRepresentable_compareExchange_acquiringAndReleasing_acquiring), + ("test_RawRepresentable_compareExchange_acquiringAndReleasing_relaxed", test_RawRepresentable_compareExchange_acquiringAndReleasing_relaxed), + ("test_RawRepresentable_compareExchange_acquiringAndReleasing_sequentiallyConsistent", test_RawRepresentable_compareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_RawRepresentable_compareExchange_relaxed", test_RawRepresentable_compareExchange_relaxed), + ("test_RawRepresentable_compareExchange_relaxed_acquiring", test_RawRepresentable_compareExchange_relaxed_acquiring), + ("test_RawRepresentable_compareExchange_relaxed_relaxed", test_RawRepresentable_compareExchange_relaxed_relaxed), + ("test_RawRepresentable_compareExchange_relaxed_sequentiallyConsistent", test_RawRepresentable_compareExchange_relaxed_sequentiallyConsistent), + ("test_RawRepresentable_compareExchange_releasing", test_RawRepresentable_compareExchange_releasing), + ("test_RawRepresentable_compareExchange_releasing_acquiring", test_RawRepresentable_compareExchange_releasing_acquiring), + ("test_RawRepresentable_compareExchange_releasing_relaxed", test_RawRepresentable_compareExchange_releasing_relaxed), + ("test_RawRepresentable_compareExchange_releasing_sequentiallyConsistent", test_RawRepresentable_compareExchange_releasing_sequentiallyConsistent), + ("test_RawRepresentable_compareExchange_sequentiallyConsistent", test_RawRepresentable_compareExchange_sequentiallyConsistent), + ("test_RawRepresentable_compareExchange_sequentiallyConsistent_acquiring", test_RawRepresentable_compareExchange_sequentiallyConsistent_acquiring), + ("test_RawRepresentable_compareExchange_sequentiallyConsistent_relaxed", test_RawRepresentable_compareExchange_sequentiallyConsistent_relaxed), + ("test_RawRepresentable_compareExchange_sequentiallyConsistent_sequentiallyConsistent", test_RawRepresentable_compareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_RawRepresentable_create_destroy", test_RawRepresentable_create_destroy), + ("test_RawRepresentable_exchange_acquiring", test_RawRepresentable_exchange_acquiring), + ("test_RawRepresentable_exchange_acquiringAndReleasing", test_RawRepresentable_exchange_acquiringAndReleasing), + ("test_RawRepresentable_exchange_relaxed", test_RawRepresentable_exchange_relaxed), + ("test_RawRepresentable_exchange_releasing", test_RawRepresentable_exchange_releasing), + ("test_RawRepresentable_exchange_sequentiallyConsistent", test_RawRepresentable_exchange_sequentiallyConsistent), + ("test_RawRepresentable_load_acquiring", test_RawRepresentable_load_acquiring), + ("test_RawRepresentable_load_relaxed", test_RawRepresentable_load_relaxed), + ("test_RawRepresentable_load_sequentiallyConsistent", test_RawRepresentable_load_sequentiallyConsistent), + ("test_RawRepresentable_store_relaxed", test_RawRepresentable_store_relaxed), + ("test_RawRepresentable_store_releasing", test_RawRepresentable_store_releasing), + ("test_RawRepresentable_store_sequentiallyConsistent", test_RawRepresentable_store_sequentiallyConsistent), + ("test_RawRepresentable_weakCompareExchange_acquiring_acquiring", test_RawRepresentable_weakCompareExchange_acquiring_acquiring), + ("test_RawRepresentable_weakCompareExchange_acquiring_relaxed", test_RawRepresentable_weakCompareExchange_acquiring_relaxed), + ("test_RawRepresentable_weakCompareExchange_acquiring_sequentiallyConsistent", test_RawRepresentable_weakCompareExchange_acquiring_sequentiallyConsistent), + ("test_RawRepresentable_weakCompareExchange_acquiringAndReleasing_acquiring", test_RawRepresentable_weakCompareExchange_acquiringAndReleasing_acquiring), + ("test_RawRepresentable_weakCompareExchange_acquiringAndReleasing_relaxed", test_RawRepresentable_weakCompareExchange_acquiringAndReleasing_relaxed), + ("test_RawRepresentable_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent", test_RawRepresentable_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_RawRepresentable_weakCompareExchange_relaxed_acquiring", test_RawRepresentable_weakCompareExchange_relaxed_acquiring), + ("test_RawRepresentable_weakCompareExchange_relaxed_relaxed", test_RawRepresentable_weakCompareExchange_relaxed_relaxed), + ("test_RawRepresentable_weakCompareExchange_relaxed_sequentiallyConsistent", test_RawRepresentable_weakCompareExchange_relaxed_sequentiallyConsistent), + ("test_RawRepresentable_weakCompareExchange_releasing_acquiring", test_RawRepresentable_weakCompareExchange_releasing_acquiring), + ("test_RawRepresentable_weakCompareExchange_releasing_relaxed", test_RawRepresentable_weakCompareExchange_releasing_relaxed), + ("test_RawRepresentable_weakCompareExchange_releasing_sequentiallyConsistent", test_RawRepresentable_weakCompareExchange_releasing_sequentiallyConsistent), + ("test_RawRepresentable_weakCompareExchange_sequentiallyConsistent_acquiring", test_RawRepresentable_weakCompareExchange_sequentiallyConsistent_acquiring), + ("test_RawRepresentable_weakCompareExchange_sequentiallyConsistent_relaxed", test_RawRepresentable_weakCompareExchange_sequentiallyConsistent_relaxed), + ("test_RawRepresentable_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent", test_RawRepresentable_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_Reference_compareExchange_acquiring", test_Reference_compareExchange_acquiring), + ("test_Reference_compareExchange_acquiring_acquiring", test_Reference_compareExchange_acquiring_acquiring), + ("test_Reference_compareExchange_acquiring_relaxed", test_Reference_compareExchange_acquiring_relaxed), + ("test_Reference_compareExchange_acquiring_sequentiallyConsistent", test_Reference_compareExchange_acquiring_sequentiallyConsistent), + ("test_Reference_compareExchange_acquiringAndReleasing", test_Reference_compareExchange_acquiringAndReleasing), + ("test_Reference_compareExchange_acquiringAndReleasing_acquiring", test_Reference_compareExchange_acquiringAndReleasing_acquiring), + ("test_Reference_compareExchange_acquiringAndReleasing_relaxed", test_Reference_compareExchange_acquiringAndReleasing_relaxed), + ("test_Reference_compareExchange_acquiringAndReleasing_sequentiallyConsistent", test_Reference_compareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_Reference_compareExchange_relaxed", test_Reference_compareExchange_relaxed), + ("test_Reference_compareExchange_relaxed_acquiring", test_Reference_compareExchange_relaxed_acquiring), + ("test_Reference_compareExchange_relaxed_relaxed", test_Reference_compareExchange_relaxed_relaxed), + ("test_Reference_compareExchange_relaxed_sequentiallyConsistent", test_Reference_compareExchange_relaxed_sequentiallyConsistent), + ("test_Reference_compareExchange_releasing", test_Reference_compareExchange_releasing), + ("test_Reference_compareExchange_releasing_acquiring", test_Reference_compareExchange_releasing_acquiring), + ("test_Reference_compareExchange_releasing_relaxed", test_Reference_compareExchange_releasing_relaxed), + ("test_Reference_compareExchange_releasing_sequentiallyConsistent", test_Reference_compareExchange_releasing_sequentiallyConsistent), + ("test_Reference_compareExchange_sequentiallyConsistent", test_Reference_compareExchange_sequentiallyConsistent), + ("test_Reference_compareExchange_sequentiallyConsistent_acquiring", test_Reference_compareExchange_sequentiallyConsistent_acquiring), + ("test_Reference_compareExchange_sequentiallyConsistent_relaxed", test_Reference_compareExchange_sequentiallyConsistent_relaxed), + ("test_Reference_compareExchange_sequentiallyConsistent_sequentiallyConsistent", test_Reference_compareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_Reference_create_destroy", test_Reference_create_destroy), + ("test_Reference_exchange_acquiring", test_Reference_exchange_acquiring), + ("test_Reference_exchange_acquiringAndReleasing", test_Reference_exchange_acquiringAndReleasing), + ("test_Reference_exchange_relaxed", test_Reference_exchange_relaxed), + ("test_Reference_exchange_releasing", test_Reference_exchange_releasing), + ("test_Reference_exchange_sequentiallyConsistent", test_Reference_exchange_sequentiallyConsistent), + ("test_Reference_load_acquiring", test_Reference_load_acquiring), + ("test_Reference_load_relaxed", test_Reference_load_relaxed), + ("test_Reference_load_sequentiallyConsistent", test_Reference_load_sequentiallyConsistent), + ("test_Reference_store_relaxed", test_Reference_store_relaxed), + ("test_Reference_store_releasing", test_Reference_store_releasing), + ("test_Reference_store_sequentiallyConsistent", test_Reference_store_sequentiallyConsistent), + ("test_Reference_weakCompareExchange_acquiring_acquiring", test_Reference_weakCompareExchange_acquiring_acquiring), + ("test_Reference_weakCompareExchange_acquiring_relaxed", test_Reference_weakCompareExchange_acquiring_relaxed), + ("test_Reference_weakCompareExchange_acquiring_sequentiallyConsistent", test_Reference_weakCompareExchange_acquiring_sequentiallyConsistent), + ("test_Reference_weakCompareExchange_acquiringAndReleasing_acquiring", test_Reference_weakCompareExchange_acquiringAndReleasing_acquiring), + ("test_Reference_weakCompareExchange_acquiringAndReleasing_relaxed", test_Reference_weakCompareExchange_acquiringAndReleasing_relaxed), + ("test_Reference_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent", test_Reference_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_Reference_weakCompareExchange_relaxed_acquiring", test_Reference_weakCompareExchange_relaxed_acquiring), + ("test_Reference_weakCompareExchange_relaxed_relaxed", test_Reference_weakCompareExchange_relaxed_relaxed), + ("test_Reference_weakCompareExchange_relaxed_sequentiallyConsistent", test_Reference_weakCompareExchange_relaxed_sequentiallyConsistent), + ("test_Reference_weakCompareExchange_releasing_acquiring", test_Reference_weakCompareExchange_releasing_acquiring), + ("test_Reference_weakCompareExchange_releasing_relaxed", test_Reference_weakCompareExchange_releasing_relaxed), + ("test_Reference_weakCompareExchange_releasing_sequentiallyConsistent", test_Reference_weakCompareExchange_releasing_sequentiallyConsistent), + ("test_Reference_weakCompareExchange_sequentiallyConsistent_acquiring", test_Reference_weakCompareExchange_sequentiallyConsistent_acquiring), + ("test_Reference_weakCompareExchange_sequentiallyConsistent_relaxed", test_Reference_weakCompareExchange_sequentiallyConsistent_relaxed), + ("test_Reference_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent", test_Reference_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_UInt16_bitwiseAndThenLoad_acquiring", test_UInt16_bitwiseAndThenLoad_acquiring), + ("test_UInt16_bitwiseAndThenLoad_acquiringAndReleasing", test_UInt16_bitwiseAndThenLoad_acquiringAndReleasing), + ("test_UInt16_bitwiseAndThenLoad_relaxed", test_UInt16_bitwiseAndThenLoad_relaxed), + ("test_UInt16_bitwiseAndThenLoad_releasing", test_UInt16_bitwiseAndThenLoad_releasing), + ("test_UInt16_bitwiseAndThenLoad_sequentiallyConsistent", test_UInt16_bitwiseAndThenLoad_sequentiallyConsistent), + ("test_UInt16_bitwiseOrThenLoad_acquiring", test_UInt16_bitwiseOrThenLoad_acquiring), + ("test_UInt16_bitwiseOrThenLoad_acquiringAndReleasing", test_UInt16_bitwiseOrThenLoad_acquiringAndReleasing), + ("test_UInt16_bitwiseOrThenLoad_relaxed", test_UInt16_bitwiseOrThenLoad_relaxed), + ("test_UInt16_bitwiseOrThenLoad_releasing", test_UInt16_bitwiseOrThenLoad_releasing), + ("test_UInt16_bitwiseOrThenLoad_sequentiallyConsistent", test_UInt16_bitwiseOrThenLoad_sequentiallyConsistent), + ("test_UInt16_bitwiseXorThenLoad_acquiring", test_UInt16_bitwiseXorThenLoad_acquiring), + ("test_UInt16_bitwiseXorThenLoad_acquiringAndReleasing", test_UInt16_bitwiseXorThenLoad_acquiringAndReleasing), + ("test_UInt16_bitwiseXorThenLoad_relaxed", test_UInt16_bitwiseXorThenLoad_relaxed), + ("test_UInt16_bitwiseXorThenLoad_releasing", test_UInt16_bitwiseXorThenLoad_releasing), + ("test_UInt16_bitwiseXorThenLoad_sequentiallyConsistent", test_UInt16_bitwiseXorThenLoad_sequentiallyConsistent), + ("test_UInt16_compareExchange_acquiring", test_UInt16_compareExchange_acquiring), + ("test_UInt16_compareExchange_acquiring_acquiring", test_UInt16_compareExchange_acquiring_acquiring), + ("test_UInt16_compareExchange_acquiring_relaxed", test_UInt16_compareExchange_acquiring_relaxed), + ("test_UInt16_compareExchange_acquiring_sequentiallyConsistent", test_UInt16_compareExchange_acquiring_sequentiallyConsistent), + ("test_UInt16_compareExchange_acquiringAndReleasing", test_UInt16_compareExchange_acquiringAndReleasing), + ("test_UInt16_compareExchange_acquiringAndReleasing_acquiring", test_UInt16_compareExchange_acquiringAndReleasing_acquiring), + ("test_UInt16_compareExchange_acquiringAndReleasing_relaxed", test_UInt16_compareExchange_acquiringAndReleasing_relaxed), + ("test_UInt16_compareExchange_acquiringAndReleasing_sequentiallyConsistent", test_UInt16_compareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_UInt16_compareExchange_relaxed", test_UInt16_compareExchange_relaxed), + ("test_UInt16_compareExchange_relaxed_acquiring", test_UInt16_compareExchange_relaxed_acquiring), + ("test_UInt16_compareExchange_relaxed_relaxed", test_UInt16_compareExchange_relaxed_relaxed), + ("test_UInt16_compareExchange_relaxed_sequentiallyConsistent", test_UInt16_compareExchange_relaxed_sequentiallyConsistent), + ("test_UInt16_compareExchange_releasing", test_UInt16_compareExchange_releasing), + ("test_UInt16_compareExchange_releasing_acquiring", test_UInt16_compareExchange_releasing_acquiring), + ("test_UInt16_compareExchange_releasing_relaxed", test_UInt16_compareExchange_releasing_relaxed), + ("test_UInt16_compareExchange_releasing_sequentiallyConsistent", test_UInt16_compareExchange_releasing_sequentiallyConsistent), + ("test_UInt16_compareExchange_sequentiallyConsistent", test_UInt16_compareExchange_sequentiallyConsistent), + ("test_UInt16_compareExchange_sequentiallyConsistent_acquiring", test_UInt16_compareExchange_sequentiallyConsistent_acquiring), + ("test_UInt16_compareExchange_sequentiallyConsistent_relaxed", test_UInt16_compareExchange_sequentiallyConsistent_relaxed), + ("test_UInt16_compareExchange_sequentiallyConsistent_sequentiallyConsistent", test_UInt16_compareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_UInt16_create_destroy", test_UInt16_create_destroy), + ("test_UInt16_exchange_acquiring", test_UInt16_exchange_acquiring), + ("test_UInt16_exchange_acquiringAndReleasing", test_UInt16_exchange_acquiringAndReleasing), + ("test_UInt16_exchange_relaxed", test_UInt16_exchange_relaxed), + ("test_UInt16_exchange_releasing", test_UInt16_exchange_releasing), + ("test_UInt16_exchange_sequentiallyConsistent", test_UInt16_exchange_sequentiallyConsistent), + ("test_UInt16_load_acquiring", test_UInt16_load_acquiring), + ("test_UInt16_load_relaxed", test_UInt16_load_relaxed), + ("test_UInt16_load_sequentiallyConsistent", test_UInt16_load_sequentiallyConsistent), + ("test_UInt16_loadThenBitwiseAnd_acquiring", test_UInt16_loadThenBitwiseAnd_acquiring), + ("test_UInt16_loadThenBitwiseAnd_acquiringAndReleasing", test_UInt16_loadThenBitwiseAnd_acquiringAndReleasing), + ("test_UInt16_loadThenBitwiseAnd_relaxed", test_UInt16_loadThenBitwiseAnd_relaxed), + ("test_UInt16_loadThenBitwiseAnd_releasing", test_UInt16_loadThenBitwiseAnd_releasing), + ("test_UInt16_loadThenBitwiseAnd_sequentiallyConsistent", test_UInt16_loadThenBitwiseAnd_sequentiallyConsistent), + ("test_UInt16_loadThenBitwiseOr_acquiring", test_UInt16_loadThenBitwiseOr_acquiring), + ("test_UInt16_loadThenBitwiseOr_acquiringAndReleasing", test_UInt16_loadThenBitwiseOr_acquiringAndReleasing), + ("test_UInt16_loadThenBitwiseOr_relaxed", test_UInt16_loadThenBitwiseOr_relaxed), + ("test_UInt16_loadThenBitwiseOr_releasing", test_UInt16_loadThenBitwiseOr_releasing), + ("test_UInt16_loadThenBitwiseOr_sequentiallyConsistent", test_UInt16_loadThenBitwiseOr_sequentiallyConsistent), + ("test_UInt16_loadThenBitwiseXor_acquiring", test_UInt16_loadThenBitwiseXor_acquiring), + ("test_UInt16_loadThenBitwiseXor_acquiringAndReleasing", test_UInt16_loadThenBitwiseXor_acquiringAndReleasing), + ("test_UInt16_loadThenBitwiseXor_relaxed", test_UInt16_loadThenBitwiseXor_relaxed), + ("test_UInt16_loadThenBitwiseXor_releasing", test_UInt16_loadThenBitwiseXor_releasing), + ("test_UInt16_loadThenBitwiseXor_sequentiallyConsistent", test_UInt16_loadThenBitwiseXor_sequentiallyConsistent), + ("test_UInt16_loadThenWrappingDecrement_acquiring", test_UInt16_loadThenWrappingDecrement_acquiring), + ("test_UInt16_loadThenWrappingDecrement_acquiringAndReleasing", test_UInt16_loadThenWrappingDecrement_acquiringAndReleasing), + ("test_UInt16_loadThenWrappingDecrement_relaxed", test_UInt16_loadThenWrappingDecrement_relaxed), + ("test_UInt16_loadThenWrappingDecrement_releasing", test_UInt16_loadThenWrappingDecrement_releasing), + ("test_UInt16_loadThenWrappingDecrement_sequentiallyConsistent", test_UInt16_loadThenWrappingDecrement_sequentiallyConsistent), + ("test_UInt16_loadThenWrappingIncrement_acquiring", test_UInt16_loadThenWrappingIncrement_acquiring), + ("test_UInt16_loadThenWrappingIncrement_acquiringAndReleasing", test_UInt16_loadThenWrappingIncrement_acquiringAndReleasing), + ("test_UInt16_loadThenWrappingIncrement_relaxed", test_UInt16_loadThenWrappingIncrement_relaxed), + ("test_UInt16_loadThenWrappingIncrement_releasing", test_UInt16_loadThenWrappingIncrement_releasing), + ("test_UInt16_loadThenWrappingIncrement_sequentiallyConsistent", test_UInt16_loadThenWrappingIncrement_sequentiallyConsistent), + ("test_UInt16_store_relaxed", test_UInt16_store_relaxed), + ("test_UInt16_store_releasing", test_UInt16_store_releasing), + ("test_UInt16_store_sequentiallyConsistent", test_UInt16_store_sequentiallyConsistent), + ("test_UInt16_weakCompareExchange_acquiring_acquiring", test_UInt16_weakCompareExchange_acquiring_acquiring), + ("test_UInt16_weakCompareExchange_acquiring_relaxed", test_UInt16_weakCompareExchange_acquiring_relaxed), + ("test_UInt16_weakCompareExchange_acquiring_sequentiallyConsistent", test_UInt16_weakCompareExchange_acquiring_sequentiallyConsistent), + ("test_UInt16_weakCompareExchange_acquiringAndReleasing_acquiring", test_UInt16_weakCompareExchange_acquiringAndReleasing_acquiring), + ("test_UInt16_weakCompareExchange_acquiringAndReleasing_relaxed", test_UInt16_weakCompareExchange_acquiringAndReleasing_relaxed), + ("test_UInt16_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent", test_UInt16_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_UInt16_weakCompareExchange_relaxed_acquiring", test_UInt16_weakCompareExchange_relaxed_acquiring), + ("test_UInt16_weakCompareExchange_relaxed_relaxed", test_UInt16_weakCompareExchange_relaxed_relaxed), + ("test_UInt16_weakCompareExchange_relaxed_sequentiallyConsistent", test_UInt16_weakCompareExchange_relaxed_sequentiallyConsistent), + ("test_UInt16_weakCompareExchange_releasing_acquiring", test_UInt16_weakCompareExchange_releasing_acquiring), + ("test_UInt16_weakCompareExchange_releasing_relaxed", test_UInt16_weakCompareExchange_releasing_relaxed), + ("test_UInt16_weakCompareExchange_releasing_sequentiallyConsistent", test_UInt16_weakCompareExchange_releasing_sequentiallyConsistent), + ("test_UInt16_weakCompareExchange_sequentiallyConsistent_acquiring", test_UInt16_weakCompareExchange_sequentiallyConsistent_acquiring), + ("test_UInt16_weakCompareExchange_sequentiallyConsistent_relaxed", test_UInt16_weakCompareExchange_sequentiallyConsistent_relaxed), + ("test_UInt16_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent", test_UInt16_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_UInt16_wrappingDecrementThenLoad_acquiring", test_UInt16_wrappingDecrementThenLoad_acquiring), + ("test_UInt16_wrappingDecrementThenLoad_acquiringAndReleasing", test_UInt16_wrappingDecrementThenLoad_acquiringAndReleasing), + ("test_UInt16_wrappingDecrementThenLoad_relaxed", test_UInt16_wrappingDecrementThenLoad_relaxed), + ("test_UInt16_wrappingDecrementThenLoad_releasing", test_UInt16_wrappingDecrementThenLoad_releasing), + ("test_UInt16_wrappingDecrementThenLoad_sequentiallyConsistent", test_UInt16_wrappingDecrementThenLoad_sequentiallyConsistent), + ("test_UInt16_wrappingIncrementThenLoad_acquiring", test_UInt16_wrappingIncrementThenLoad_acquiring), + ("test_UInt16_wrappingIncrementThenLoad_acquiringAndReleasing", test_UInt16_wrappingIncrementThenLoad_acquiringAndReleasing), + ("test_UInt16_wrappingIncrementThenLoad_relaxed", test_UInt16_wrappingIncrementThenLoad_relaxed), + ("test_UInt16_wrappingIncrementThenLoad_releasing", test_UInt16_wrappingIncrementThenLoad_releasing), + ("test_UInt16_wrappingIncrementThenLoad_sequentiallyConsistent", test_UInt16_wrappingIncrementThenLoad_sequentiallyConsistent), + ("test_UInt32_bitwiseAndThenLoad_acquiring", test_UInt32_bitwiseAndThenLoad_acquiring), + ("test_UInt32_bitwiseAndThenLoad_acquiringAndReleasing", test_UInt32_bitwiseAndThenLoad_acquiringAndReleasing), + ("test_UInt32_bitwiseAndThenLoad_relaxed", test_UInt32_bitwiseAndThenLoad_relaxed), + ("test_UInt32_bitwiseAndThenLoad_releasing", test_UInt32_bitwiseAndThenLoad_releasing), + ("test_UInt32_bitwiseAndThenLoad_sequentiallyConsistent", test_UInt32_bitwiseAndThenLoad_sequentiallyConsistent), + ("test_UInt32_bitwiseOrThenLoad_acquiring", test_UInt32_bitwiseOrThenLoad_acquiring), + ("test_UInt32_bitwiseOrThenLoad_acquiringAndReleasing", test_UInt32_bitwiseOrThenLoad_acquiringAndReleasing), + ("test_UInt32_bitwiseOrThenLoad_relaxed", test_UInt32_bitwiseOrThenLoad_relaxed), + ("test_UInt32_bitwiseOrThenLoad_releasing", test_UInt32_bitwiseOrThenLoad_releasing), + ("test_UInt32_bitwiseOrThenLoad_sequentiallyConsistent", test_UInt32_bitwiseOrThenLoad_sequentiallyConsistent), + ("test_UInt32_bitwiseXorThenLoad_acquiring", test_UInt32_bitwiseXorThenLoad_acquiring), + ("test_UInt32_bitwiseXorThenLoad_acquiringAndReleasing", test_UInt32_bitwiseXorThenLoad_acquiringAndReleasing), + ("test_UInt32_bitwiseXorThenLoad_relaxed", test_UInt32_bitwiseXorThenLoad_relaxed), + ("test_UInt32_bitwiseXorThenLoad_releasing", test_UInt32_bitwiseXorThenLoad_releasing), + ("test_UInt32_bitwiseXorThenLoad_sequentiallyConsistent", test_UInt32_bitwiseXorThenLoad_sequentiallyConsistent), + ("test_UInt32_compareExchange_acquiring", test_UInt32_compareExchange_acquiring), + ("test_UInt32_compareExchange_acquiring_acquiring", test_UInt32_compareExchange_acquiring_acquiring), + ("test_UInt32_compareExchange_acquiring_relaxed", test_UInt32_compareExchange_acquiring_relaxed), + ("test_UInt32_compareExchange_acquiring_sequentiallyConsistent", test_UInt32_compareExchange_acquiring_sequentiallyConsistent), + ("test_UInt32_compareExchange_acquiringAndReleasing", test_UInt32_compareExchange_acquiringAndReleasing), + ("test_UInt32_compareExchange_acquiringAndReleasing_acquiring", test_UInt32_compareExchange_acquiringAndReleasing_acquiring), + ("test_UInt32_compareExchange_acquiringAndReleasing_relaxed", test_UInt32_compareExchange_acquiringAndReleasing_relaxed), + ("test_UInt32_compareExchange_acquiringAndReleasing_sequentiallyConsistent", test_UInt32_compareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_UInt32_compareExchange_relaxed", test_UInt32_compareExchange_relaxed), + ("test_UInt32_compareExchange_relaxed_acquiring", test_UInt32_compareExchange_relaxed_acquiring), + ("test_UInt32_compareExchange_relaxed_relaxed", test_UInt32_compareExchange_relaxed_relaxed), + ("test_UInt32_compareExchange_relaxed_sequentiallyConsistent", test_UInt32_compareExchange_relaxed_sequentiallyConsistent), + ("test_UInt32_compareExchange_releasing", test_UInt32_compareExchange_releasing), + ("test_UInt32_compareExchange_releasing_acquiring", test_UInt32_compareExchange_releasing_acquiring), + ("test_UInt32_compareExchange_releasing_relaxed", test_UInt32_compareExchange_releasing_relaxed), + ("test_UInt32_compareExchange_releasing_sequentiallyConsistent", test_UInt32_compareExchange_releasing_sequentiallyConsistent), + ("test_UInt32_compareExchange_sequentiallyConsistent", test_UInt32_compareExchange_sequentiallyConsistent), + ("test_UInt32_compareExchange_sequentiallyConsistent_acquiring", test_UInt32_compareExchange_sequentiallyConsistent_acquiring), + ("test_UInt32_compareExchange_sequentiallyConsistent_relaxed", test_UInt32_compareExchange_sequentiallyConsistent_relaxed), + ("test_UInt32_compareExchange_sequentiallyConsistent_sequentiallyConsistent", test_UInt32_compareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_UInt32_create_destroy", test_UInt32_create_destroy), + ("test_UInt32_exchange_acquiring", test_UInt32_exchange_acquiring), + ("test_UInt32_exchange_acquiringAndReleasing", test_UInt32_exchange_acquiringAndReleasing), + ("test_UInt32_exchange_relaxed", test_UInt32_exchange_relaxed), + ("test_UInt32_exchange_releasing", test_UInt32_exchange_releasing), + ("test_UInt32_exchange_sequentiallyConsistent", test_UInt32_exchange_sequentiallyConsistent), + ("test_UInt32_load_acquiring", test_UInt32_load_acquiring), + ("test_UInt32_load_relaxed", test_UInt32_load_relaxed), + ("test_UInt32_load_sequentiallyConsistent", test_UInt32_load_sequentiallyConsistent), + ("test_UInt32_loadThenBitwiseAnd_acquiring", test_UInt32_loadThenBitwiseAnd_acquiring), + ("test_UInt32_loadThenBitwiseAnd_acquiringAndReleasing", test_UInt32_loadThenBitwiseAnd_acquiringAndReleasing), + ("test_UInt32_loadThenBitwiseAnd_relaxed", test_UInt32_loadThenBitwiseAnd_relaxed), + ("test_UInt32_loadThenBitwiseAnd_releasing", test_UInt32_loadThenBitwiseAnd_releasing), + ("test_UInt32_loadThenBitwiseAnd_sequentiallyConsistent", test_UInt32_loadThenBitwiseAnd_sequentiallyConsistent), + ("test_UInt32_loadThenBitwiseOr_acquiring", test_UInt32_loadThenBitwiseOr_acquiring), + ("test_UInt32_loadThenBitwiseOr_acquiringAndReleasing", test_UInt32_loadThenBitwiseOr_acquiringAndReleasing), + ("test_UInt32_loadThenBitwiseOr_relaxed", test_UInt32_loadThenBitwiseOr_relaxed), + ("test_UInt32_loadThenBitwiseOr_releasing", test_UInt32_loadThenBitwiseOr_releasing), + ("test_UInt32_loadThenBitwiseOr_sequentiallyConsistent", test_UInt32_loadThenBitwiseOr_sequentiallyConsistent), + ("test_UInt32_loadThenBitwiseXor_acquiring", test_UInt32_loadThenBitwiseXor_acquiring), + ("test_UInt32_loadThenBitwiseXor_acquiringAndReleasing", test_UInt32_loadThenBitwiseXor_acquiringAndReleasing), + ("test_UInt32_loadThenBitwiseXor_relaxed", test_UInt32_loadThenBitwiseXor_relaxed), + ("test_UInt32_loadThenBitwiseXor_releasing", test_UInt32_loadThenBitwiseXor_releasing), + ("test_UInt32_loadThenBitwiseXor_sequentiallyConsistent", test_UInt32_loadThenBitwiseXor_sequentiallyConsistent), + ("test_UInt32_loadThenWrappingDecrement_acquiring", test_UInt32_loadThenWrappingDecrement_acquiring), + ("test_UInt32_loadThenWrappingDecrement_acquiringAndReleasing", test_UInt32_loadThenWrappingDecrement_acquiringAndReleasing), + ("test_UInt32_loadThenWrappingDecrement_relaxed", test_UInt32_loadThenWrappingDecrement_relaxed), + ("test_UInt32_loadThenWrappingDecrement_releasing", test_UInt32_loadThenWrappingDecrement_releasing), + ("test_UInt32_loadThenWrappingDecrement_sequentiallyConsistent", test_UInt32_loadThenWrappingDecrement_sequentiallyConsistent), + ("test_UInt32_loadThenWrappingIncrement_acquiring", test_UInt32_loadThenWrappingIncrement_acquiring), + ("test_UInt32_loadThenWrappingIncrement_acquiringAndReleasing", test_UInt32_loadThenWrappingIncrement_acquiringAndReleasing), + ("test_UInt32_loadThenWrappingIncrement_relaxed", test_UInt32_loadThenWrappingIncrement_relaxed), + ("test_UInt32_loadThenWrappingIncrement_releasing", test_UInt32_loadThenWrappingIncrement_releasing), + ("test_UInt32_loadThenWrappingIncrement_sequentiallyConsistent", test_UInt32_loadThenWrappingIncrement_sequentiallyConsistent), + ("test_UInt32_store_relaxed", test_UInt32_store_relaxed), + ("test_UInt32_store_releasing", test_UInt32_store_releasing), + ("test_UInt32_store_sequentiallyConsistent", test_UInt32_store_sequentiallyConsistent), + ("test_UInt32_weakCompareExchange_acquiring_acquiring", test_UInt32_weakCompareExchange_acquiring_acquiring), + ("test_UInt32_weakCompareExchange_acquiring_relaxed", test_UInt32_weakCompareExchange_acquiring_relaxed), + ("test_UInt32_weakCompareExchange_acquiring_sequentiallyConsistent", test_UInt32_weakCompareExchange_acquiring_sequentiallyConsistent), + ("test_UInt32_weakCompareExchange_acquiringAndReleasing_acquiring", test_UInt32_weakCompareExchange_acquiringAndReleasing_acquiring), + ("test_UInt32_weakCompareExchange_acquiringAndReleasing_relaxed", test_UInt32_weakCompareExchange_acquiringAndReleasing_relaxed), + ("test_UInt32_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent", test_UInt32_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_UInt32_weakCompareExchange_relaxed_acquiring", test_UInt32_weakCompareExchange_relaxed_acquiring), + ("test_UInt32_weakCompareExchange_relaxed_relaxed", test_UInt32_weakCompareExchange_relaxed_relaxed), + ("test_UInt32_weakCompareExchange_relaxed_sequentiallyConsistent", test_UInt32_weakCompareExchange_relaxed_sequentiallyConsistent), + ("test_UInt32_weakCompareExchange_releasing_acquiring", test_UInt32_weakCompareExchange_releasing_acquiring), + ("test_UInt32_weakCompareExchange_releasing_relaxed", test_UInt32_weakCompareExchange_releasing_relaxed), + ("test_UInt32_weakCompareExchange_releasing_sequentiallyConsistent", test_UInt32_weakCompareExchange_releasing_sequentiallyConsistent), + ("test_UInt32_weakCompareExchange_sequentiallyConsistent_acquiring", test_UInt32_weakCompareExchange_sequentiallyConsistent_acquiring), + ("test_UInt32_weakCompareExchange_sequentiallyConsistent_relaxed", test_UInt32_weakCompareExchange_sequentiallyConsistent_relaxed), + ("test_UInt32_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent", test_UInt32_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_UInt32_wrappingDecrementThenLoad_acquiring", test_UInt32_wrappingDecrementThenLoad_acquiring), + ("test_UInt32_wrappingDecrementThenLoad_acquiringAndReleasing", test_UInt32_wrappingDecrementThenLoad_acquiringAndReleasing), + ("test_UInt32_wrappingDecrementThenLoad_relaxed", test_UInt32_wrappingDecrementThenLoad_relaxed), + ("test_UInt32_wrappingDecrementThenLoad_releasing", test_UInt32_wrappingDecrementThenLoad_releasing), + ("test_UInt32_wrappingDecrementThenLoad_sequentiallyConsistent", test_UInt32_wrappingDecrementThenLoad_sequentiallyConsistent), + ("test_UInt32_wrappingIncrementThenLoad_acquiring", test_UInt32_wrappingIncrementThenLoad_acquiring), + ("test_UInt32_wrappingIncrementThenLoad_acquiringAndReleasing", test_UInt32_wrappingIncrementThenLoad_acquiringAndReleasing), + ("test_UInt32_wrappingIncrementThenLoad_relaxed", test_UInt32_wrappingIncrementThenLoad_relaxed), + ("test_UInt32_wrappingIncrementThenLoad_releasing", test_UInt32_wrappingIncrementThenLoad_releasing), + ("test_UInt32_wrappingIncrementThenLoad_sequentiallyConsistent", test_UInt32_wrappingIncrementThenLoad_sequentiallyConsistent), + ("test_UInt64_bitwiseAndThenLoad_acquiring", test_UInt64_bitwiseAndThenLoad_acquiring), + ("test_UInt64_bitwiseAndThenLoad_acquiringAndReleasing", test_UInt64_bitwiseAndThenLoad_acquiringAndReleasing), + ("test_UInt64_bitwiseAndThenLoad_relaxed", test_UInt64_bitwiseAndThenLoad_relaxed), + ("test_UInt64_bitwiseAndThenLoad_releasing", test_UInt64_bitwiseAndThenLoad_releasing), + ("test_UInt64_bitwiseAndThenLoad_sequentiallyConsistent", test_UInt64_bitwiseAndThenLoad_sequentiallyConsistent), + ("test_UInt64_bitwiseOrThenLoad_acquiring", test_UInt64_bitwiseOrThenLoad_acquiring), + ("test_UInt64_bitwiseOrThenLoad_acquiringAndReleasing", test_UInt64_bitwiseOrThenLoad_acquiringAndReleasing), + ("test_UInt64_bitwiseOrThenLoad_relaxed", test_UInt64_bitwiseOrThenLoad_relaxed), + ("test_UInt64_bitwiseOrThenLoad_releasing", test_UInt64_bitwiseOrThenLoad_releasing), + ("test_UInt64_bitwiseOrThenLoad_sequentiallyConsistent", test_UInt64_bitwiseOrThenLoad_sequentiallyConsistent), + ("test_UInt64_bitwiseXorThenLoad_acquiring", test_UInt64_bitwiseXorThenLoad_acquiring), + ("test_UInt64_bitwiseXorThenLoad_acquiringAndReleasing", test_UInt64_bitwiseXorThenLoad_acquiringAndReleasing), + ("test_UInt64_bitwiseXorThenLoad_relaxed", test_UInt64_bitwiseXorThenLoad_relaxed), + ("test_UInt64_bitwiseXorThenLoad_releasing", test_UInt64_bitwiseXorThenLoad_releasing), + ("test_UInt64_bitwiseXorThenLoad_sequentiallyConsistent", test_UInt64_bitwiseXorThenLoad_sequentiallyConsistent), + ("test_UInt64_compareExchange_acquiring", test_UInt64_compareExchange_acquiring), + ("test_UInt64_compareExchange_acquiring_acquiring", test_UInt64_compareExchange_acquiring_acquiring), + ("test_UInt64_compareExchange_acquiring_relaxed", test_UInt64_compareExchange_acquiring_relaxed), + ("test_UInt64_compareExchange_acquiring_sequentiallyConsistent", test_UInt64_compareExchange_acquiring_sequentiallyConsistent), + ("test_UInt64_compareExchange_acquiringAndReleasing", test_UInt64_compareExchange_acquiringAndReleasing), + ("test_UInt64_compareExchange_acquiringAndReleasing_acquiring", test_UInt64_compareExchange_acquiringAndReleasing_acquiring), + ("test_UInt64_compareExchange_acquiringAndReleasing_relaxed", test_UInt64_compareExchange_acquiringAndReleasing_relaxed), + ("test_UInt64_compareExchange_acquiringAndReleasing_sequentiallyConsistent", test_UInt64_compareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_UInt64_compareExchange_relaxed", test_UInt64_compareExchange_relaxed), + ("test_UInt64_compareExchange_relaxed_acquiring", test_UInt64_compareExchange_relaxed_acquiring), + ("test_UInt64_compareExchange_relaxed_relaxed", test_UInt64_compareExchange_relaxed_relaxed), + ("test_UInt64_compareExchange_relaxed_sequentiallyConsistent", test_UInt64_compareExchange_relaxed_sequentiallyConsistent), + ("test_UInt64_compareExchange_releasing", test_UInt64_compareExchange_releasing), + ("test_UInt64_compareExchange_releasing_acquiring", test_UInt64_compareExchange_releasing_acquiring), + ("test_UInt64_compareExchange_releasing_relaxed", test_UInt64_compareExchange_releasing_relaxed), + ("test_UInt64_compareExchange_releasing_sequentiallyConsistent", test_UInt64_compareExchange_releasing_sequentiallyConsistent), + ("test_UInt64_compareExchange_sequentiallyConsistent", test_UInt64_compareExchange_sequentiallyConsistent), + ("test_UInt64_compareExchange_sequentiallyConsistent_acquiring", test_UInt64_compareExchange_sequentiallyConsistent_acquiring), + ("test_UInt64_compareExchange_sequentiallyConsistent_relaxed", test_UInt64_compareExchange_sequentiallyConsistent_relaxed), + ("test_UInt64_compareExchange_sequentiallyConsistent_sequentiallyConsistent", test_UInt64_compareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_UInt64_create_destroy", test_UInt64_create_destroy), + ("test_UInt64_exchange_acquiring", test_UInt64_exchange_acquiring), + ("test_UInt64_exchange_acquiringAndReleasing", test_UInt64_exchange_acquiringAndReleasing), + ("test_UInt64_exchange_relaxed", test_UInt64_exchange_relaxed), + ("test_UInt64_exchange_releasing", test_UInt64_exchange_releasing), + ("test_UInt64_exchange_sequentiallyConsistent", test_UInt64_exchange_sequentiallyConsistent), + ("test_UInt64_load_acquiring", test_UInt64_load_acquiring), + ("test_UInt64_load_relaxed", test_UInt64_load_relaxed), + ("test_UInt64_load_sequentiallyConsistent", test_UInt64_load_sequentiallyConsistent), + ("test_UInt64_loadThenBitwiseAnd_acquiring", test_UInt64_loadThenBitwiseAnd_acquiring), + ("test_UInt64_loadThenBitwiseAnd_acquiringAndReleasing", test_UInt64_loadThenBitwiseAnd_acquiringAndReleasing), + ("test_UInt64_loadThenBitwiseAnd_relaxed", test_UInt64_loadThenBitwiseAnd_relaxed), + ("test_UInt64_loadThenBitwiseAnd_releasing", test_UInt64_loadThenBitwiseAnd_releasing), + ("test_UInt64_loadThenBitwiseAnd_sequentiallyConsistent", test_UInt64_loadThenBitwiseAnd_sequentiallyConsistent), + ("test_UInt64_loadThenBitwiseOr_acquiring", test_UInt64_loadThenBitwiseOr_acquiring), + ("test_UInt64_loadThenBitwiseOr_acquiringAndReleasing", test_UInt64_loadThenBitwiseOr_acquiringAndReleasing), + ("test_UInt64_loadThenBitwiseOr_relaxed", test_UInt64_loadThenBitwiseOr_relaxed), + ("test_UInt64_loadThenBitwiseOr_releasing", test_UInt64_loadThenBitwiseOr_releasing), + ("test_UInt64_loadThenBitwiseOr_sequentiallyConsistent", test_UInt64_loadThenBitwiseOr_sequentiallyConsistent), + ("test_UInt64_loadThenBitwiseXor_acquiring", test_UInt64_loadThenBitwiseXor_acquiring), + ("test_UInt64_loadThenBitwiseXor_acquiringAndReleasing", test_UInt64_loadThenBitwiseXor_acquiringAndReleasing), + ("test_UInt64_loadThenBitwiseXor_relaxed", test_UInt64_loadThenBitwiseXor_relaxed), + ("test_UInt64_loadThenBitwiseXor_releasing", test_UInt64_loadThenBitwiseXor_releasing), + ("test_UInt64_loadThenBitwiseXor_sequentiallyConsistent", test_UInt64_loadThenBitwiseXor_sequentiallyConsistent), + ("test_UInt64_loadThenWrappingDecrement_acquiring", test_UInt64_loadThenWrappingDecrement_acquiring), + ("test_UInt64_loadThenWrappingDecrement_acquiringAndReleasing", test_UInt64_loadThenWrappingDecrement_acquiringAndReleasing), + ("test_UInt64_loadThenWrappingDecrement_relaxed", test_UInt64_loadThenWrappingDecrement_relaxed), + ("test_UInt64_loadThenWrappingDecrement_releasing", test_UInt64_loadThenWrappingDecrement_releasing), + ("test_UInt64_loadThenWrappingDecrement_sequentiallyConsistent", test_UInt64_loadThenWrappingDecrement_sequentiallyConsistent), + ("test_UInt64_loadThenWrappingIncrement_acquiring", test_UInt64_loadThenWrappingIncrement_acquiring), + ("test_UInt64_loadThenWrappingIncrement_acquiringAndReleasing", test_UInt64_loadThenWrappingIncrement_acquiringAndReleasing), + ("test_UInt64_loadThenWrappingIncrement_relaxed", test_UInt64_loadThenWrappingIncrement_relaxed), + ("test_UInt64_loadThenWrappingIncrement_releasing", test_UInt64_loadThenWrappingIncrement_releasing), + ("test_UInt64_loadThenWrappingIncrement_sequentiallyConsistent", test_UInt64_loadThenWrappingIncrement_sequentiallyConsistent), + ("test_UInt64_store_relaxed", test_UInt64_store_relaxed), + ("test_UInt64_store_releasing", test_UInt64_store_releasing), + ("test_UInt64_store_sequentiallyConsistent", test_UInt64_store_sequentiallyConsistent), + ("test_UInt64_weakCompareExchange_acquiring_acquiring", test_UInt64_weakCompareExchange_acquiring_acquiring), + ("test_UInt64_weakCompareExchange_acquiring_relaxed", test_UInt64_weakCompareExchange_acquiring_relaxed), + ("test_UInt64_weakCompareExchange_acquiring_sequentiallyConsistent", test_UInt64_weakCompareExchange_acquiring_sequentiallyConsistent), + ("test_UInt64_weakCompareExchange_acquiringAndReleasing_acquiring", test_UInt64_weakCompareExchange_acquiringAndReleasing_acquiring), + ("test_UInt64_weakCompareExchange_acquiringAndReleasing_relaxed", test_UInt64_weakCompareExchange_acquiringAndReleasing_relaxed), + ("test_UInt64_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent", test_UInt64_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_UInt64_weakCompareExchange_relaxed_acquiring", test_UInt64_weakCompareExchange_relaxed_acquiring), + ("test_UInt64_weakCompareExchange_relaxed_relaxed", test_UInt64_weakCompareExchange_relaxed_relaxed), + ("test_UInt64_weakCompareExchange_relaxed_sequentiallyConsistent", test_UInt64_weakCompareExchange_relaxed_sequentiallyConsistent), + ("test_UInt64_weakCompareExchange_releasing_acquiring", test_UInt64_weakCompareExchange_releasing_acquiring), + ("test_UInt64_weakCompareExchange_releasing_relaxed", test_UInt64_weakCompareExchange_releasing_relaxed), + ("test_UInt64_weakCompareExchange_releasing_sequentiallyConsistent", test_UInt64_weakCompareExchange_releasing_sequentiallyConsistent), + ("test_UInt64_weakCompareExchange_sequentiallyConsistent_acquiring", test_UInt64_weakCompareExchange_sequentiallyConsistent_acquiring), + ("test_UInt64_weakCompareExchange_sequentiallyConsistent_relaxed", test_UInt64_weakCompareExchange_sequentiallyConsistent_relaxed), + ("test_UInt64_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent", test_UInt64_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_UInt64_wrappingDecrementThenLoad_acquiring", test_UInt64_wrappingDecrementThenLoad_acquiring), + ("test_UInt64_wrappingDecrementThenLoad_acquiringAndReleasing", test_UInt64_wrappingDecrementThenLoad_acquiringAndReleasing), + ("test_UInt64_wrappingDecrementThenLoad_relaxed", test_UInt64_wrappingDecrementThenLoad_relaxed), + ("test_UInt64_wrappingDecrementThenLoad_releasing", test_UInt64_wrappingDecrementThenLoad_releasing), + ("test_UInt64_wrappingDecrementThenLoad_sequentiallyConsistent", test_UInt64_wrappingDecrementThenLoad_sequentiallyConsistent), + ("test_UInt64_wrappingIncrementThenLoad_acquiring", test_UInt64_wrappingIncrementThenLoad_acquiring), + ("test_UInt64_wrappingIncrementThenLoad_acquiringAndReleasing", test_UInt64_wrappingIncrementThenLoad_acquiringAndReleasing), + ("test_UInt64_wrappingIncrementThenLoad_relaxed", test_UInt64_wrappingIncrementThenLoad_relaxed), + ("test_UInt64_wrappingIncrementThenLoad_releasing", test_UInt64_wrappingIncrementThenLoad_releasing), + ("test_UInt64_wrappingIncrementThenLoad_sequentiallyConsistent", test_UInt64_wrappingIncrementThenLoad_sequentiallyConsistent), + ("test_UInt8_bitwiseAndThenLoad_acquiring", test_UInt8_bitwiseAndThenLoad_acquiring), + ("test_UInt8_bitwiseAndThenLoad_acquiringAndReleasing", test_UInt8_bitwiseAndThenLoad_acquiringAndReleasing), + ("test_UInt8_bitwiseAndThenLoad_relaxed", test_UInt8_bitwiseAndThenLoad_relaxed), + ("test_UInt8_bitwiseAndThenLoad_releasing", test_UInt8_bitwiseAndThenLoad_releasing), + ("test_UInt8_bitwiseAndThenLoad_sequentiallyConsistent", test_UInt8_bitwiseAndThenLoad_sequentiallyConsistent), + ("test_UInt8_bitwiseOrThenLoad_acquiring", test_UInt8_bitwiseOrThenLoad_acquiring), + ("test_UInt8_bitwiseOrThenLoad_acquiringAndReleasing", test_UInt8_bitwiseOrThenLoad_acquiringAndReleasing), + ("test_UInt8_bitwiseOrThenLoad_relaxed", test_UInt8_bitwiseOrThenLoad_relaxed), + ("test_UInt8_bitwiseOrThenLoad_releasing", test_UInt8_bitwiseOrThenLoad_releasing), + ("test_UInt8_bitwiseOrThenLoad_sequentiallyConsistent", test_UInt8_bitwiseOrThenLoad_sequentiallyConsistent), + ("test_UInt8_bitwiseXorThenLoad_acquiring", test_UInt8_bitwiseXorThenLoad_acquiring), + ("test_UInt8_bitwiseXorThenLoad_acquiringAndReleasing", test_UInt8_bitwiseXorThenLoad_acquiringAndReleasing), + ("test_UInt8_bitwiseXorThenLoad_relaxed", test_UInt8_bitwiseXorThenLoad_relaxed), + ("test_UInt8_bitwiseXorThenLoad_releasing", test_UInt8_bitwiseXorThenLoad_releasing), + ("test_UInt8_bitwiseXorThenLoad_sequentiallyConsistent", test_UInt8_bitwiseXorThenLoad_sequentiallyConsistent), + ("test_UInt8_compareExchange_acquiring", test_UInt8_compareExchange_acquiring), + ("test_UInt8_compareExchange_acquiring_acquiring", test_UInt8_compareExchange_acquiring_acquiring), + ("test_UInt8_compareExchange_acquiring_relaxed", test_UInt8_compareExchange_acquiring_relaxed), + ("test_UInt8_compareExchange_acquiring_sequentiallyConsistent", test_UInt8_compareExchange_acquiring_sequentiallyConsistent), + ("test_UInt8_compareExchange_acquiringAndReleasing", test_UInt8_compareExchange_acquiringAndReleasing), + ("test_UInt8_compareExchange_acquiringAndReleasing_acquiring", test_UInt8_compareExchange_acquiringAndReleasing_acquiring), + ("test_UInt8_compareExchange_acquiringAndReleasing_relaxed", test_UInt8_compareExchange_acquiringAndReleasing_relaxed), + ("test_UInt8_compareExchange_acquiringAndReleasing_sequentiallyConsistent", test_UInt8_compareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_UInt8_compareExchange_relaxed", test_UInt8_compareExchange_relaxed), + ("test_UInt8_compareExchange_relaxed_acquiring", test_UInt8_compareExchange_relaxed_acquiring), + ("test_UInt8_compareExchange_relaxed_relaxed", test_UInt8_compareExchange_relaxed_relaxed), + ("test_UInt8_compareExchange_relaxed_sequentiallyConsistent", test_UInt8_compareExchange_relaxed_sequentiallyConsistent), + ("test_UInt8_compareExchange_releasing", test_UInt8_compareExchange_releasing), + ("test_UInt8_compareExchange_releasing_acquiring", test_UInt8_compareExchange_releasing_acquiring), + ("test_UInt8_compareExchange_releasing_relaxed", test_UInt8_compareExchange_releasing_relaxed), + ("test_UInt8_compareExchange_releasing_sequentiallyConsistent", test_UInt8_compareExchange_releasing_sequentiallyConsistent), + ("test_UInt8_compareExchange_sequentiallyConsistent", test_UInt8_compareExchange_sequentiallyConsistent), + ("test_UInt8_compareExchange_sequentiallyConsistent_acquiring", test_UInt8_compareExchange_sequentiallyConsistent_acquiring), + ("test_UInt8_compareExchange_sequentiallyConsistent_relaxed", test_UInt8_compareExchange_sequentiallyConsistent_relaxed), + ("test_UInt8_compareExchange_sequentiallyConsistent_sequentiallyConsistent", test_UInt8_compareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_UInt8_create_destroy", test_UInt8_create_destroy), + ("test_UInt8_exchange_acquiring", test_UInt8_exchange_acquiring), + ("test_UInt8_exchange_acquiringAndReleasing", test_UInt8_exchange_acquiringAndReleasing), + ("test_UInt8_exchange_relaxed", test_UInt8_exchange_relaxed), + ("test_UInt8_exchange_releasing", test_UInt8_exchange_releasing), + ("test_UInt8_exchange_sequentiallyConsistent", test_UInt8_exchange_sequentiallyConsistent), + ("test_UInt8_load_acquiring", test_UInt8_load_acquiring), + ("test_UInt8_load_relaxed", test_UInt8_load_relaxed), + ("test_UInt8_load_sequentiallyConsistent", test_UInt8_load_sequentiallyConsistent), + ("test_UInt8_loadThenBitwiseAnd_acquiring", test_UInt8_loadThenBitwiseAnd_acquiring), + ("test_UInt8_loadThenBitwiseAnd_acquiringAndReleasing", test_UInt8_loadThenBitwiseAnd_acquiringAndReleasing), + ("test_UInt8_loadThenBitwiseAnd_relaxed", test_UInt8_loadThenBitwiseAnd_relaxed), + ("test_UInt8_loadThenBitwiseAnd_releasing", test_UInt8_loadThenBitwiseAnd_releasing), + ("test_UInt8_loadThenBitwiseAnd_sequentiallyConsistent", test_UInt8_loadThenBitwiseAnd_sequentiallyConsistent), + ("test_UInt8_loadThenBitwiseOr_acquiring", test_UInt8_loadThenBitwiseOr_acquiring), + ("test_UInt8_loadThenBitwiseOr_acquiringAndReleasing", test_UInt8_loadThenBitwiseOr_acquiringAndReleasing), + ("test_UInt8_loadThenBitwiseOr_relaxed", test_UInt8_loadThenBitwiseOr_relaxed), + ("test_UInt8_loadThenBitwiseOr_releasing", test_UInt8_loadThenBitwiseOr_releasing), + ("test_UInt8_loadThenBitwiseOr_sequentiallyConsistent", test_UInt8_loadThenBitwiseOr_sequentiallyConsistent), + ("test_UInt8_loadThenBitwiseXor_acquiring", test_UInt8_loadThenBitwiseXor_acquiring), + ("test_UInt8_loadThenBitwiseXor_acquiringAndReleasing", test_UInt8_loadThenBitwiseXor_acquiringAndReleasing), + ("test_UInt8_loadThenBitwiseXor_relaxed", test_UInt8_loadThenBitwiseXor_relaxed), + ("test_UInt8_loadThenBitwiseXor_releasing", test_UInt8_loadThenBitwiseXor_releasing), + ("test_UInt8_loadThenBitwiseXor_sequentiallyConsistent", test_UInt8_loadThenBitwiseXor_sequentiallyConsistent), + ("test_UInt8_loadThenWrappingDecrement_acquiring", test_UInt8_loadThenWrappingDecrement_acquiring), + ("test_UInt8_loadThenWrappingDecrement_acquiringAndReleasing", test_UInt8_loadThenWrappingDecrement_acquiringAndReleasing), + ("test_UInt8_loadThenWrappingDecrement_relaxed", test_UInt8_loadThenWrappingDecrement_relaxed), + ("test_UInt8_loadThenWrappingDecrement_releasing", test_UInt8_loadThenWrappingDecrement_releasing), + ("test_UInt8_loadThenWrappingDecrement_sequentiallyConsistent", test_UInt8_loadThenWrappingDecrement_sequentiallyConsistent), + ("test_UInt8_loadThenWrappingIncrement_acquiring", test_UInt8_loadThenWrappingIncrement_acquiring), + ("test_UInt8_loadThenWrappingIncrement_acquiringAndReleasing", test_UInt8_loadThenWrappingIncrement_acquiringAndReleasing), + ("test_UInt8_loadThenWrappingIncrement_relaxed", test_UInt8_loadThenWrappingIncrement_relaxed), + ("test_UInt8_loadThenWrappingIncrement_releasing", test_UInt8_loadThenWrappingIncrement_releasing), + ("test_UInt8_loadThenWrappingIncrement_sequentiallyConsistent", test_UInt8_loadThenWrappingIncrement_sequentiallyConsistent), + ("test_UInt8_store_relaxed", test_UInt8_store_relaxed), + ("test_UInt8_store_releasing", test_UInt8_store_releasing), + ("test_UInt8_store_sequentiallyConsistent", test_UInt8_store_sequentiallyConsistent), + ("test_UInt8_weakCompareExchange_acquiring_acquiring", test_UInt8_weakCompareExchange_acquiring_acquiring), + ("test_UInt8_weakCompareExchange_acquiring_relaxed", test_UInt8_weakCompareExchange_acquiring_relaxed), + ("test_UInt8_weakCompareExchange_acquiring_sequentiallyConsistent", test_UInt8_weakCompareExchange_acquiring_sequentiallyConsistent), + ("test_UInt8_weakCompareExchange_acquiringAndReleasing_acquiring", test_UInt8_weakCompareExchange_acquiringAndReleasing_acquiring), + ("test_UInt8_weakCompareExchange_acquiringAndReleasing_relaxed", test_UInt8_weakCompareExchange_acquiringAndReleasing_relaxed), + ("test_UInt8_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent", test_UInt8_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_UInt8_weakCompareExchange_relaxed_acquiring", test_UInt8_weakCompareExchange_relaxed_acquiring), + ("test_UInt8_weakCompareExchange_relaxed_relaxed", test_UInt8_weakCompareExchange_relaxed_relaxed), + ("test_UInt8_weakCompareExchange_relaxed_sequentiallyConsistent", test_UInt8_weakCompareExchange_relaxed_sequentiallyConsistent), + ("test_UInt8_weakCompareExchange_releasing_acquiring", test_UInt8_weakCompareExchange_releasing_acquiring), + ("test_UInt8_weakCompareExchange_releasing_relaxed", test_UInt8_weakCompareExchange_releasing_relaxed), + ("test_UInt8_weakCompareExchange_releasing_sequentiallyConsistent", test_UInt8_weakCompareExchange_releasing_sequentiallyConsistent), + ("test_UInt8_weakCompareExchange_sequentiallyConsistent_acquiring", test_UInt8_weakCompareExchange_sequentiallyConsistent_acquiring), + ("test_UInt8_weakCompareExchange_sequentiallyConsistent_relaxed", test_UInt8_weakCompareExchange_sequentiallyConsistent_relaxed), + ("test_UInt8_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent", test_UInt8_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_UInt8_wrappingDecrementThenLoad_acquiring", test_UInt8_wrappingDecrementThenLoad_acquiring), + ("test_UInt8_wrappingDecrementThenLoad_acquiringAndReleasing", test_UInt8_wrappingDecrementThenLoad_acquiringAndReleasing), + ("test_UInt8_wrappingDecrementThenLoad_relaxed", test_UInt8_wrappingDecrementThenLoad_relaxed), + ("test_UInt8_wrappingDecrementThenLoad_releasing", test_UInt8_wrappingDecrementThenLoad_releasing), + ("test_UInt8_wrappingDecrementThenLoad_sequentiallyConsistent", test_UInt8_wrappingDecrementThenLoad_sequentiallyConsistent), + ("test_UInt8_wrappingIncrementThenLoad_acquiring", test_UInt8_wrappingIncrementThenLoad_acquiring), + ("test_UInt8_wrappingIncrementThenLoad_acquiringAndReleasing", test_UInt8_wrappingIncrementThenLoad_acquiringAndReleasing), + ("test_UInt8_wrappingIncrementThenLoad_relaxed", test_UInt8_wrappingIncrementThenLoad_relaxed), + ("test_UInt8_wrappingIncrementThenLoad_releasing", test_UInt8_wrappingIncrementThenLoad_releasing), + ("test_UInt8_wrappingIncrementThenLoad_sequentiallyConsistent", test_UInt8_wrappingIncrementThenLoad_sequentiallyConsistent), + ("test_UInt_bitwiseAndThenLoad_acquiring", test_UInt_bitwiseAndThenLoad_acquiring), + ("test_UInt_bitwiseAndThenLoad_acquiringAndReleasing", test_UInt_bitwiseAndThenLoad_acquiringAndReleasing), + ("test_UInt_bitwiseAndThenLoad_relaxed", test_UInt_bitwiseAndThenLoad_relaxed), + ("test_UInt_bitwiseAndThenLoad_releasing", test_UInt_bitwiseAndThenLoad_releasing), + ("test_UInt_bitwiseAndThenLoad_sequentiallyConsistent", test_UInt_bitwiseAndThenLoad_sequentiallyConsistent), + ("test_UInt_bitwiseOrThenLoad_acquiring", test_UInt_bitwiseOrThenLoad_acquiring), + ("test_UInt_bitwiseOrThenLoad_acquiringAndReleasing", test_UInt_bitwiseOrThenLoad_acquiringAndReleasing), + ("test_UInt_bitwiseOrThenLoad_relaxed", test_UInt_bitwiseOrThenLoad_relaxed), + ("test_UInt_bitwiseOrThenLoad_releasing", test_UInt_bitwiseOrThenLoad_releasing), + ("test_UInt_bitwiseOrThenLoad_sequentiallyConsistent", test_UInt_bitwiseOrThenLoad_sequentiallyConsistent), + ("test_UInt_bitwiseXorThenLoad_acquiring", test_UInt_bitwiseXorThenLoad_acquiring), + ("test_UInt_bitwiseXorThenLoad_acquiringAndReleasing", test_UInt_bitwiseXorThenLoad_acquiringAndReleasing), + ("test_UInt_bitwiseXorThenLoad_relaxed", test_UInt_bitwiseXorThenLoad_relaxed), + ("test_UInt_bitwiseXorThenLoad_releasing", test_UInt_bitwiseXorThenLoad_releasing), + ("test_UInt_bitwiseXorThenLoad_sequentiallyConsistent", test_UInt_bitwiseXorThenLoad_sequentiallyConsistent), + ("test_UInt_compareExchange_acquiring", test_UInt_compareExchange_acquiring), + ("test_UInt_compareExchange_acquiring_acquiring", test_UInt_compareExchange_acquiring_acquiring), + ("test_UInt_compareExchange_acquiring_relaxed", test_UInt_compareExchange_acquiring_relaxed), + ("test_UInt_compareExchange_acquiring_sequentiallyConsistent", test_UInt_compareExchange_acquiring_sequentiallyConsistent), + ("test_UInt_compareExchange_acquiringAndReleasing", test_UInt_compareExchange_acquiringAndReleasing), + ("test_UInt_compareExchange_acquiringAndReleasing_acquiring", test_UInt_compareExchange_acquiringAndReleasing_acquiring), + ("test_UInt_compareExchange_acquiringAndReleasing_relaxed", test_UInt_compareExchange_acquiringAndReleasing_relaxed), + ("test_UInt_compareExchange_acquiringAndReleasing_sequentiallyConsistent", test_UInt_compareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_UInt_compareExchange_relaxed", test_UInt_compareExchange_relaxed), + ("test_UInt_compareExchange_relaxed_acquiring", test_UInt_compareExchange_relaxed_acquiring), + ("test_UInt_compareExchange_relaxed_relaxed", test_UInt_compareExchange_relaxed_relaxed), + ("test_UInt_compareExchange_relaxed_sequentiallyConsistent", test_UInt_compareExchange_relaxed_sequentiallyConsistent), + ("test_UInt_compareExchange_releasing", test_UInt_compareExchange_releasing), + ("test_UInt_compareExchange_releasing_acquiring", test_UInt_compareExchange_releasing_acquiring), + ("test_UInt_compareExchange_releasing_relaxed", test_UInt_compareExchange_releasing_relaxed), + ("test_UInt_compareExchange_releasing_sequentiallyConsistent", test_UInt_compareExchange_releasing_sequentiallyConsistent), + ("test_UInt_compareExchange_sequentiallyConsistent", test_UInt_compareExchange_sequentiallyConsistent), + ("test_UInt_compareExchange_sequentiallyConsistent_acquiring", test_UInt_compareExchange_sequentiallyConsistent_acquiring), + ("test_UInt_compareExchange_sequentiallyConsistent_relaxed", test_UInt_compareExchange_sequentiallyConsistent_relaxed), + ("test_UInt_compareExchange_sequentiallyConsistent_sequentiallyConsistent", test_UInt_compareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_UInt_create_destroy", test_UInt_create_destroy), + ("test_UInt_exchange_acquiring", test_UInt_exchange_acquiring), + ("test_UInt_exchange_acquiringAndReleasing", test_UInt_exchange_acquiringAndReleasing), + ("test_UInt_exchange_relaxed", test_UInt_exchange_relaxed), + ("test_UInt_exchange_releasing", test_UInt_exchange_releasing), + ("test_UInt_exchange_sequentiallyConsistent", test_UInt_exchange_sequentiallyConsistent), + ("test_UInt_load_acquiring", test_UInt_load_acquiring), + ("test_UInt_load_relaxed", test_UInt_load_relaxed), + ("test_UInt_load_sequentiallyConsistent", test_UInt_load_sequentiallyConsistent), + ("test_UInt_loadThenBitwiseAnd_acquiring", test_UInt_loadThenBitwiseAnd_acquiring), + ("test_UInt_loadThenBitwiseAnd_acquiringAndReleasing", test_UInt_loadThenBitwiseAnd_acquiringAndReleasing), + ("test_UInt_loadThenBitwiseAnd_relaxed", test_UInt_loadThenBitwiseAnd_relaxed), + ("test_UInt_loadThenBitwiseAnd_releasing", test_UInt_loadThenBitwiseAnd_releasing), + ("test_UInt_loadThenBitwiseAnd_sequentiallyConsistent", test_UInt_loadThenBitwiseAnd_sequentiallyConsistent), + ("test_UInt_loadThenBitwiseOr_acquiring", test_UInt_loadThenBitwiseOr_acquiring), + ("test_UInt_loadThenBitwiseOr_acquiringAndReleasing", test_UInt_loadThenBitwiseOr_acquiringAndReleasing), + ("test_UInt_loadThenBitwiseOr_relaxed", test_UInt_loadThenBitwiseOr_relaxed), + ("test_UInt_loadThenBitwiseOr_releasing", test_UInt_loadThenBitwiseOr_releasing), + ("test_UInt_loadThenBitwiseOr_sequentiallyConsistent", test_UInt_loadThenBitwiseOr_sequentiallyConsistent), + ("test_UInt_loadThenBitwiseXor_acquiring", test_UInt_loadThenBitwiseXor_acquiring), + ("test_UInt_loadThenBitwiseXor_acquiringAndReleasing", test_UInt_loadThenBitwiseXor_acquiringAndReleasing), + ("test_UInt_loadThenBitwiseXor_relaxed", test_UInt_loadThenBitwiseXor_relaxed), + ("test_UInt_loadThenBitwiseXor_releasing", test_UInt_loadThenBitwiseXor_releasing), + ("test_UInt_loadThenBitwiseXor_sequentiallyConsistent", test_UInt_loadThenBitwiseXor_sequentiallyConsistent), + ("test_UInt_loadThenWrappingDecrement_acquiring", test_UInt_loadThenWrappingDecrement_acquiring), + ("test_UInt_loadThenWrappingDecrement_acquiringAndReleasing", test_UInt_loadThenWrappingDecrement_acquiringAndReleasing), + ("test_UInt_loadThenWrappingDecrement_relaxed", test_UInt_loadThenWrappingDecrement_relaxed), + ("test_UInt_loadThenWrappingDecrement_releasing", test_UInt_loadThenWrappingDecrement_releasing), + ("test_UInt_loadThenWrappingDecrement_sequentiallyConsistent", test_UInt_loadThenWrappingDecrement_sequentiallyConsistent), + ("test_UInt_loadThenWrappingIncrement_acquiring", test_UInt_loadThenWrappingIncrement_acquiring), + ("test_UInt_loadThenWrappingIncrement_acquiringAndReleasing", test_UInt_loadThenWrappingIncrement_acquiringAndReleasing), + ("test_UInt_loadThenWrappingIncrement_relaxed", test_UInt_loadThenWrappingIncrement_relaxed), + ("test_UInt_loadThenWrappingIncrement_releasing", test_UInt_loadThenWrappingIncrement_releasing), + ("test_UInt_loadThenWrappingIncrement_sequentiallyConsistent", test_UInt_loadThenWrappingIncrement_sequentiallyConsistent), + ("test_UInt_store_relaxed", test_UInt_store_relaxed), + ("test_UInt_store_releasing", test_UInt_store_releasing), + ("test_UInt_store_sequentiallyConsistent", test_UInt_store_sequentiallyConsistent), + ("test_UInt_weakCompareExchange_acquiring_acquiring", test_UInt_weakCompareExchange_acquiring_acquiring), + ("test_UInt_weakCompareExchange_acquiring_relaxed", test_UInt_weakCompareExchange_acquiring_relaxed), + ("test_UInt_weakCompareExchange_acquiring_sequentiallyConsistent", test_UInt_weakCompareExchange_acquiring_sequentiallyConsistent), + ("test_UInt_weakCompareExchange_acquiringAndReleasing_acquiring", test_UInt_weakCompareExchange_acquiringAndReleasing_acquiring), + ("test_UInt_weakCompareExchange_acquiringAndReleasing_relaxed", test_UInt_weakCompareExchange_acquiringAndReleasing_relaxed), + ("test_UInt_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent", test_UInt_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_UInt_weakCompareExchange_relaxed_acquiring", test_UInt_weakCompareExchange_relaxed_acquiring), + ("test_UInt_weakCompareExchange_relaxed_relaxed", test_UInt_weakCompareExchange_relaxed_relaxed), + ("test_UInt_weakCompareExchange_relaxed_sequentiallyConsistent", test_UInt_weakCompareExchange_relaxed_sequentiallyConsistent), + ("test_UInt_weakCompareExchange_releasing_acquiring", test_UInt_weakCompareExchange_releasing_acquiring), + ("test_UInt_weakCompareExchange_releasing_relaxed", test_UInt_weakCompareExchange_releasing_relaxed), + ("test_UInt_weakCompareExchange_releasing_sequentiallyConsistent", test_UInt_weakCompareExchange_releasing_sequentiallyConsistent), + ("test_UInt_weakCompareExchange_sequentiallyConsistent_acquiring", test_UInt_weakCompareExchange_sequentiallyConsistent_acquiring), + ("test_UInt_weakCompareExchange_sequentiallyConsistent_relaxed", test_UInt_weakCompareExchange_sequentiallyConsistent_relaxed), + ("test_UInt_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent", test_UInt_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_UInt_wrappingDecrementThenLoad_acquiring", test_UInt_wrappingDecrementThenLoad_acquiring), + ("test_UInt_wrappingDecrementThenLoad_acquiringAndReleasing", test_UInt_wrappingDecrementThenLoad_acquiringAndReleasing), + ("test_UInt_wrappingDecrementThenLoad_relaxed", test_UInt_wrappingDecrementThenLoad_relaxed), + ("test_UInt_wrappingDecrementThenLoad_releasing", test_UInt_wrappingDecrementThenLoad_releasing), + ("test_UInt_wrappingDecrementThenLoad_sequentiallyConsistent", test_UInt_wrappingDecrementThenLoad_sequentiallyConsistent), + ("test_UInt_wrappingIncrementThenLoad_acquiring", test_UInt_wrappingIncrementThenLoad_acquiring), + ("test_UInt_wrappingIncrementThenLoad_acquiringAndReleasing", test_UInt_wrappingIncrementThenLoad_acquiringAndReleasing), + ("test_UInt_wrappingIncrementThenLoad_relaxed", test_UInt_wrappingIncrementThenLoad_relaxed), + ("test_UInt_wrappingIncrementThenLoad_releasing", test_UInt_wrappingIncrementThenLoad_releasing), + ("test_UInt_wrappingIncrementThenLoad_sequentiallyConsistent", test_UInt_wrappingIncrementThenLoad_sequentiallyConsistent), + ("test_Unmanaged_compareExchange_acquiring", test_Unmanaged_compareExchange_acquiring), + ("test_Unmanaged_compareExchange_acquiring_acquiring", test_Unmanaged_compareExchange_acquiring_acquiring), + ("test_Unmanaged_compareExchange_acquiring_relaxed", test_Unmanaged_compareExchange_acquiring_relaxed), + ("test_Unmanaged_compareExchange_acquiring_sequentiallyConsistent", test_Unmanaged_compareExchange_acquiring_sequentiallyConsistent), + ("test_Unmanaged_compareExchange_acquiringAndReleasing", test_Unmanaged_compareExchange_acquiringAndReleasing), + ("test_Unmanaged_compareExchange_acquiringAndReleasing_acquiring", test_Unmanaged_compareExchange_acquiringAndReleasing_acquiring), + ("test_Unmanaged_compareExchange_acquiringAndReleasing_relaxed", test_Unmanaged_compareExchange_acquiringAndReleasing_relaxed), + ("test_Unmanaged_compareExchange_acquiringAndReleasing_sequentiallyConsistent", test_Unmanaged_compareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_Unmanaged_compareExchange_relaxed", test_Unmanaged_compareExchange_relaxed), + ("test_Unmanaged_compareExchange_relaxed_acquiring", test_Unmanaged_compareExchange_relaxed_acquiring), + ("test_Unmanaged_compareExchange_relaxed_relaxed", test_Unmanaged_compareExchange_relaxed_relaxed), + ("test_Unmanaged_compareExchange_relaxed_sequentiallyConsistent", test_Unmanaged_compareExchange_relaxed_sequentiallyConsistent), + ("test_Unmanaged_compareExchange_releasing", test_Unmanaged_compareExchange_releasing), + ("test_Unmanaged_compareExchange_releasing_acquiring", test_Unmanaged_compareExchange_releasing_acquiring), + ("test_Unmanaged_compareExchange_releasing_relaxed", test_Unmanaged_compareExchange_releasing_relaxed), + ("test_Unmanaged_compareExchange_releasing_sequentiallyConsistent", test_Unmanaged_compareExchange_releasing_sequentiallyConsistent), + ("test_Unmanaged_compareExchange_sequentiallyConsistent", test_Unmanaged_compareExchange_sequentiallyConsistent), + ("test_Unmanaged_compareExchange_sequentiallyConsistent_acquiring", test_Unmanaged_compareExchange_sequentiallyConsistent_acquiring), + ("test_Unmanaged_compareExchange_sequentiallyConsistent_relaxed", test_Unmanaged_compareExchange_sequentiallyConsistent_relaxed), + ("test_Unmanaged_compareExchange_sequentiallyConsistent_sequentiallyConsistent", test_Unmanaged_compareExchange_sequentiallyConsistent_sequentiallyConsistent), + ("test_Unmanaged_create_destroy", test_Unmanaged_create_destroy), + ("test_Unmanaged_exchange_acquiring", test_Unmanaged_exchange_acquiring), + ("test_Unmanaged_exchange_acquiringAndReleasing", test_Unmanaged_exchange_acquiringAndReleasing), + ("test_Unmanaged_exchange_relaxed", test_Unmanaged_exchange_relaxed), + ("test_Unmanaged_exchange_releasing", test_Unmanaged_exchange_releasing), + ("test_Unmanaged_exchange_sequentiallyConsistent", test_Unmanaged_exchange_sequentiallyConsistent), + ("test_Unmanaged_load_acquiring", test_Unmanaged_load_acquiring), + ("test_Unmanaged_load_relaxed", test_Unmanaged_load_relaxed), + ("test_Unmanaged_load_sequentiallyConsistent", test_Unmanaged_load_sequentiallyConsistent), + ("test_Unmanaged_store_relaxed", test_Unmanaged_store_relaxed), + ("test_Unmanaged_store_releasing", test_Unmanaged_store_releasing), + ("test_Unmanaged_store_sequentiallyConsistent", test_Unmanaged_store_sequentiallyConsistent), + ("test_Unmanaged_weakCompareExchange_acquiring_acquiring", test_Unmanaged_weakCompareExchange_acquiring_acquiring), + ("test_Unmanaged_weakCompareExchange_acquiring_relaxed", test_Unmanaged_weakCompareExchange_acquiring_relaxed), + ("test_Unmanaged_weakCompareExchange_acquiring_sequentiallyConsistent", test_Unmanaged_weakCompareExchange_acquiring_sequentiallyConsistent), + ("test_Unmanaged_weakCompareExchange_acquiringAndReleasing_acquiring", test_Unmanaged_weakCompareExchange_acquiringAndReleasing_acquiring), + ("test_Unmanaged_weakCompareExchange_acquiringAndReleasing_relaxed", test_Unmanaged_weakCompareExchange_acquiringAndReleasing_relaxed), + ("test_Unmanaged_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent", test_Unmanaged_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent), + ("test_Unmanaged_weakCompareExchange_relaxed_acquiring", test_Unmanaged_weakCompareExchange_relaxed_acquiring), + ("test_Unmanaged_weakCompareExchange_relaxed_relaxed", test_Unmanaged_weakCompareExchange_relaxed_relaxed), + ("test_Unmanaged_weakCompareExchange_relaxed_sequentiallyConsistent", test_Unmanaged_weakCompareExchange_relaxed_sequentiallyConsistent), + ("test_Unmanaged_weakCompareExchange_releasing_acquiring", test_Unmanaged_weakCompareExchange_releasing_acquiring), + ("test_Unmanaged_weakCompareExchange_releasing_relaxed", test_Unmanaged_weakCompareExchange_releasing_relaxed), + ("test_Unmanaged_weakCompareExchange_releasing_sequentiallyConsistent", test_Unmanaged_weakCompareExchange_releasing_sequentiallyConsistent), + ("test_Unmanaged_weakCompareExchange_sequentiallyConsistent_acquiring", test_Unmanaged_weakCompareExchange_sequentiallyConsistent_acquiring), + ("test_Unmanaged_weakCompareExchange_sequentiallyConsistent_relaxed", test_Unmanaged_weakCompareExchange_sequentiallyConsistent_relaxed), + ("test_Unmanaged_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent", test_Unmanaged_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent), + ] +} + +extension LockFreeSingleConsumerStackTests { + // DO NOT MODIFY: This is autogenerated, use: + // `swift test --generate-linuxmain` + // to regenerate. + static let __allTests__LockFreeSingleConsumerStackTests = [ + ("test_Basics", test_Basics), + ("test_ConcurrentPushes", test_ConcurrentPushes), + ("test_ConcurrentPushesAndPops", test_ConcurrentPushesAndPops), + ] +} + +extension StrongReferenceRace { + // DO NOT MODIFY: This is autogenerated, use: + // `swift test --generate-linuxmain` + // to regenerate. + static let __allTests__StrongReferenceRace = [ + ("testCompareExchange1", testCompareExchange1), + ("testCompareExchange16", testCompareExchange16), + ("testCompareExchange2", testCompareExchange2), + ("testCompareExchange4", testCompareExchange4), + ("testCompareExchange8", testCompareExchange8), + ("testCompareExchangeNil_01", testCompareExchangeNil_01), + ("testCompareExchangeNil_02", testCompareExchangeNil_02), + ("testCompareExchangeNil_04", testCompareExchangeNil_04), + ("testCompareExchangeNil_08", testCompareExchangeNil_08), + ("testCompareExchangeNil_16", testCompareExchangeNil_16), + ("testExchange_01_01", testExchange_01_01), + ("testExchange_01_02", testExchange_01_02), + ("testExchange_01_04", testExchange_01_04), + ("testExchange_02_01", testExchange_02_01), + ("testExchange_02_02", testExchange_02_02), + ("testExchange_02_04", testExchange_02_04), + ("testExchange_04_01", testExchange_04_01), + ("testExchange_04_02", testExchange_04_02), + ("testExchange_04_04", testExchange_04_04), + ("testExchange_08_01", testExchange_08_01), + ("testExchange_08_02", testExchange_08_02), + ("testExchange_08_04", testExchange_08_04), + ("testExchange_16_01", testExchange_16_01), + ("testExchange_16_02", testExchange_16_02), + ("testExchange_16_04", testExchange_16_04), + ("testLifetimes_02", testLifetimes_02), + ("testLifetimes_04", testLifetimes_04), + ("testLifetimes_08", testLifetimes_08), + ("testLifetimes_16", testLifetimes_16), + ("testLoad1", testLoad1), + ("testLoad16", testLoad16), + ("testLoad2", testLoad2), + ("testLoad4", testLoad4), + ("testLoad8", testLoad8), + ("testLoadStore_01_01", testLoadStore_01_01), + ("testLoadStore_01_02", testLoadStore_01_02), + ("testLoadStore_01_04", testLoadStore_01_04), + ("testLoadStore_02_01", testLoadStore_02_01), + ("testLoadStore_02_02", testLoadStore_02_02), + ("testLoadStore_02_04", testLoadStore_02_04), + ("testLoadStore_04_01", testLoadStore_04_01), + ("testLoadStore_04_02", testLoadStore_04_02), + ("testLoadStore_04_04", testLoadStore_04_04), + ("testLoadStore_08_01", testLoadStore_08_01), + ("testLoadStore_08_02", testLoadStore_08_02), + ("testLoadStore_08_04", testLoadStore_08_04), + ("testLoadStore_16_01", testLoadStore_16_01), + ("testLoadStore_16_02", testLoadStore_16_02), + ("testLoadStore_16_04", testLoadStore_16_04), + ] +} + +extension StrongReferenceShuffleTests { + // DO NOT MODIFY: This is autogenerated, use: + // `swift test --generate-linuxmain` + // to regenerate. + static let __allTests__StrongReferenceShuffleTests = [ + ("test_sink_01_00", test_sink_01_00), + ("test_sink_01_01", test_sink_01_01), + ("test_sink_01_02", test_sink_01_02), + ("test_sink_01_04", test_sink_01_04), + ("test_sink_01_08", test_sink_01_08), + ("test_sink_02_00", test_sink_02_00), + ("test_sink_02_01", test_sink_02_01), + ("test_sink_02_02", test_sink_02_02), + ("test_sink_02_04", test_sink_02_04), + ("test_sink_02_08", test_sink_02_08), + ("test_sink_04_00", test_sink_04_00), + ("test_sink_04_01", test_sink_04_01), + ("test_sink_04_02", test_sink_04_02), + ("test_sink_04_04", test_sink_04_04), + ("test_sink_04_08", test_sink_04_08), + ("test_sink_08_00", test_sink_08_00), + ("test_sink_08_01", test_sink_08_01), + ("test_sink_08_02", test_sink_08_02), + ("test_sink_08_04", test_sink_08_04), + ("test_sink_08_08", test_sink_08_08), + ] +} + +extension UnsafeAtomicLazyReferenceTests { + // DO NOT MODIFY: This is autogenerated, use: + // `swift test --generate-linuxmain` + // to regenerate. + static let __allTests__UnsafeAtomicLazyReferenceTests = [ + ("test_create_destroy", test_create_destroy), + ("test_storeIfNilThenLoad", test_storeIfNilThenLoad), + ] +} + +public func __allTests() -> [XCTestCaseEntry] { + return [ + testCase(BasicAtomicTests.__allTests__BasicAtomicTests), + testCase(LockFreeSingleConsumerStackTests.__allTests__LockFreeSingleConsumerStackTests), + testCase(StrongReferenceRace.__allTests__StrongReferenceRace), + testCase(StrongReferenceShuffleTests.__allTests__StrongReferenceShuffleTests), + testCase(UnsafeAtomicLazyReferenceTests.__allTests__UnsafeAtomicLazyReferenceTests), + ] +} +#endif diff --git a/Tests/AtomicsTests/autogenerated/Basics.swift b/Tests/AtomicsTests/autogenerated/Basics.swift new file mode 100644 index 0000000..6f9176c --- /dev/null +++ b/Tests/AtomicsTests/autogenerated/Basics.swift @@ -0,0 +1,44770 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// + + +// ############################################################################# +// # # +// # DO NOT EDIT THIS FILE; IT IS AUTOGENERATED. # +// # # +// ############################################################################# + + +import XCTest +import Atomics + +extension Unmanaged: Equatable { // FIXME: This is terrible + public static func ==(left: Self, right: Self) -> Bool { + left.toOpaque() == right.toOpaque() + } +} + +private struct Foo: Equatable, CustomStringConvertible { + var value: Int + init(_ value: Int) { self.value = value } + var description: String { "Foo(\(value))" } +} + +private class Bar: Equatable, CustomStringConvertible { + var value: Int + init(_ value: Int) { self.value = value } + var description: String { "Bar(\(value))" } + static func ==(left: Bar, right: Bar) -> Bool { + left === right + } +} + +private class Baz: Equatable, CustomStringConvertible, AtomicReference { + var value: Int + init(_ value: Int) { self.value = value } + var description: String { "Bar(\(value))" } + static func ==(left: Baz, right: Baz) -> Bool { + left === right + } +} + +private enum Fred: Int, AtomicValue { + case one + case two +} + +/// Exercises all operations in a single-threaded context, verifying +/// they provide the expected results. +class BasicAtomicTests: XCTestCase { + private let _mfoo1: UnsafeMutablePointer = { + let p = UnsafeMutablePointer.allocate(capacity: 1) + p.initialize(to: Foo(1)) + return p + }() + + private let _mfoo2: UnsafeMutablePointer = { + let p = UnsafeMutablePointer.allocate(capacity: 1) + p.initialize(to: Foo(2)) + return p + }() + + private var _foo1: UnsafePointer { UnsafePointer(_mfoo1) } + private var _foo2: UnsafePointer { UnsafePointer(_mfoo2) } + + private let _raw1 = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1) + private let _raw2 = UnsafeMutableRawPointer.allocate(byteCount: 16, alignment: 1) + private let _bar1 = Unmanaged.passRetained(Bar(1)) + private let _bar2 = Unmanaged.passRetained(Bar(2)) + private let _baz1 = Baz(1) + private let _baz2 = Baz(2) + + deinit { + _mfoo1.deinitialize(count: 1) + _mfoo1.deallocate() + + _mfoo2.deinitialize(count: 1) + _mfoo2.deallocate() + + _raw1.deallocate() + _raw2.deallocate() + + _bar1.release() + _bar2.release() + } + + func test_Int_create_destroy() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), 23) + } + + func test_Int_load_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), 23) + } + func test_Int_load_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .acquiring), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .acquiring), 23) + } + func test_Int_load_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .sequentiallyConsistent), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .sequentiallyConsistent), 23) + } + + func test_Int_store_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .relaxed) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .relaxed) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + func test_Int_store_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .releasing) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .releasing) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + func test_Int_store_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .sequentiallyConsistent) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .sequentiallyConsistent) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + + func test_Int_exchange_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .relaxed), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .relaxed), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .relaxed), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_Int_exchange_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .acquiring), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .acquiring), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .acquiring), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_Int_exchange_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .releasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .releasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .releasing), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_Int_exchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .acquiringAndReleasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .acquiringAndReleasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .acquiringAndReleasing), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_Int_exchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .sequentiallyConsistent), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .sequentiallyConsistent), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .sequentiallyConsistent), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + + func test_Int_compareExchange_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_compareExchange_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_compareExchange_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_compareExchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_compareExchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + + func test_Int_compareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_compareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_compareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_compareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_compareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_compareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_compareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_compareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_compareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_compareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_compareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_compareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_compareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_compareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_compareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_weakCompareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_weakCompareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_weakCompareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_weakCompareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_weakCompareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_weakCompareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_weakCompareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_weakCompareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_weakCompareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_weakCompareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_weakCompareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_weakCompareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_weakCompareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + + +// Bool operations + + +// Integer operations + + func test_Int_loadThenWrappingIncrement_relaxed() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a &+ b + let result2: Int = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenWrappingIncrement_acquiring() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a &+ b + let result2: Int = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenWrappingIncrement_releasing() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a &+ b + let result2: Int = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenWrappingIncrement_acquiringAndReleasing() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a &+ b + let result2: Int = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenWrappingIncrement_sequentiallyConsistent() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a &+ b + let result2: Int = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenWrappingDecrement_relaxed() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a &- b + let result2: Int = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenWrappingDecrement_acquiring() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a &- b + let result2: Int = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenWrappingDecrement_releasing() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a &- b + let result2: Int = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenWrappingDecrement_acquiringAndReleasing() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a &- b + let result2: Int = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenWrappingDecrement_sequentiallyConsistent() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a &- b + let result2: Int = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenBitwiseAnd_relaxed() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a & b + let result2: Int = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenBitwiseAnd_acquiring() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a & b + let result2: Int = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenBitwiseAnd_releasing() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a & b + let result2: Int = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenBitwiseAnd_acquiringAndReleasing() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a & b + let result2: Int = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenBitwiseAnd_sequentiallyConsistent() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a & b + let result2: Int = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenBitwiseOr_relaxed() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a | b + let result2: Int = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenBitwiseOr_acquiring() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a | b + let result2: Int = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenBitwiseOr_releasing() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a | b + let result2: Int = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenBitwiseOr_acquiringAndReleasing() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a | b + let result2: Int = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenBitwiseOr_sequentiallyConsistent() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a | b + let result2: Int = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenBitwiseXor_relaxed() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a ^ b + let result2: Int = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenBitwiseXor_acquiring() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a ^ b + let result2: Int = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenBitwiseXor_releasing() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a ^ b + let result2: Int = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenBitwiseXor_acquiringAndReleasing() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a ^ b + let result2: Int = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_loadThenBitwiseXor_sequentiallyConsistent() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a ^ b + let result2: Int = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + + func test_Int_wrappingIncrementThenLoad_relaxed() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a &+ b + let result2: Int = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_wrappingIncrementThenLoad_acquiring() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a &+ b + let result2: Int = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_wrappingIncrementThenLoad_releasing() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a &+ b + let result2: Int = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_wrappingIncrementThenLoad_acquiringAndReleasing() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a &+ b + let result2: Int = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_wrappingIncrementThenLoad_sequentiallyConsistent() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a &+ b + let result2: Int = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_wrappingDecrementThenLoad_relaxed() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a &- b + let result2: Int = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_wrappingDecrementThenLoad_acquiring() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a &- b + let result2: Int = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_wrappingDecrementThenLoad_releasing() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a &- b + let result2: Int = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_wrappingDecrementThenLoad_acquiringAndReleasing() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a &- b + let result2: Int = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_wrappingDecrementThenLoad_sequentiallyConsistent() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a &- b + let result2: Int = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_bitwiseAndThenLoad_relaxed() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a & b + let result2: Int = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_bitwiseAndThenLoad_acquiring() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a & b + let result2: Int = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_bitwiseAndThenLoad_releasing() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a & b + let result2: Int = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_bitwiseAndThenLoad_acquiringAndReleasing() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a & b + let result2: Int = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_bitwiseAndThenLoad_sequentiallyConsistent() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a & b + let result2: Int = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_bitwiseOrThenLoad_relaxed() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a | b + let result2: Int = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_bitwiseOrThenLoad_acquiring() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a | b + let result2: Int = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_bitwiseOrThenLoad_releasing() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a | b + let result2: Int = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_bitwiseOrThenLoad_acquiringAndReleasing() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a | b + let result2: Int = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_bitwiseOrThenLoad_sequentiallyConsistent() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a | b + let result2: Int = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_bitwiseXorThenLoad_relaxed() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a ^ b + let result2: Int = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_bitwiseXorThenLoad_acquiring() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a ^ b + let result2: Int = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_bitwiseXorThenLoad_releasing() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a ^ b + let result2: Int = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_bitwiseXorThenLoad_acquiringAndReleasing() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a ^ b + let result2: Int = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int_bitwiseXorThenLoad_sequentiallyConsistent() { + let a: Int = 3 + let b: Int = 8 + let c: Int = 12 + let result1: Int = a ^ b + let result2: Int = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + + func test_Int8_create_destroy() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), 23) + } + + func test_Int8_load_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), 23) + } + func test_Int8_load_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .acquiring), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .acquiring), 23) + } + func test_Int8_load_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .sequentiallyConsistent), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .sequentiallyConsistent), 23) + } + + func test_Int8_store_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .relaxed) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .relaxed) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + func test_Int8_store_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .releasing) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .releasing) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + func test_Int8_store_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .sequentiallyConsistent) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .sequentiallyConsistent) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + + func test_Int8_exchange_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .relaxed), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .relaxed), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .relaxed), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_Int8_exchange_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .acquiring), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .acquiring), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .acquiring), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_Int8_exchange_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .releasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .releasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .releasing), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_Int8_exchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .acquiringAndReleasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .acquiringAndReleasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .acquiringAndReleasing), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_Int8_exchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .sequentiallyConsistent), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .sequentiallyConsistent), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .sequentiallyConsistent), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + + func test_Int8_compareExchange_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_compareExchange_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_compareExchange_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_compareExchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_compareExchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + + func test_Int8_compareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_compareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_compareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_compareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_compareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_compareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_compareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_compareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_compareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_compareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_compareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_compareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_compareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_compareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_compareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_weakCompareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_weakCompareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_weakCompareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_weakCompareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_weakCompareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_weakCompareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_weakCompareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_weakCompareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_weakCompareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_weakCompareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_weakCompareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_weakCompareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_weakCompareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int8_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + + +// Bool operations + + +// Integer operations + + func test_Int8_loadThenWrappingIncrement_relaxed() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a &+ b + let result2: Int8 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenWrappingIncrement_acquiring() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a &+ b + let result2: Int8 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenWrappingIncrement_releasing() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a &+ b + let result2: Int8 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenWrappingIncrement_acquiringAndReleasing() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a &+ b + let result2: Int8 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenWrappingIncrement_sequentiallyConsistent() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a &+ b + let result2: Int8 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenWrappingDecrement_relaxed() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a &- b + let result2: Int8 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenWrappingDecrement_acquiring() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a &- b + let result2: Int8 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenWrappingDecrement_releasing() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a &- b + let result2: Int8 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenWrappingDecrement_acquiringAndReleasing() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a &- b + let result2: Int8 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenWrappingDecrement_sequentiallyConsistent() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a &- b + let result2: Int8 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenBitwiseAnd_relaxed() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a & b + let result2: Int8 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenBitwiseAnd_acquiring() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a & b + let result2: Int8 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenBitwiseAnd_releasing() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a & b + let result2: Int8 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenBitwiseAnd_acquiringAndReleasing() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a & b + let result2: Int8 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenBitwiseAnd_sequentiallyConsistent() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a & b + let result2: Int8 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenBitwiseOr_relaxed() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a | b + let result2: Int8 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenBitwiseOr_acquiring() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a | b + let result2: Int8 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenBitwiseOr_releasing() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a | b + let result2: Int8 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenBitwiseOr_acquiringAndReleasing() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a | b + let result2: Int8 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenBitwiseOr_sequentiallyConsistent() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a | b + let result2: Int8 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenBitwiseXor_relaxed() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a ^ b + let result2: Int8 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenBitwiseXor_acquiring() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a ^ b + let result2: Int8 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenBitwiseXor_releasing() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a ^ b + let result2: Int8 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenBitwiseXor_acquiringAndReleasing() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a ^ b + let result2: Int8 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_loadThenBitwiseXor_sequentiallyConsistent() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a ^ b + let result2: Int8 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + + func test_Int8_wrappingIncrementThenLoad_relaxed() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a &+ b + let result2: Int8 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_wrappingIncrementThenLoad_acquiring() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a &+ b + let result2: Int8 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_wrappingIncrementThenLoad_releasing() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a &+ b + let result2: Int8 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_wrappingIncrementThenLoad_acquiringAndReleasing() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a &+ b + let result2: Int8 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_wrappingIncrementThenLoad_sequentiallyConsistent() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a &+ b + let result2: Int8 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_wrappingDecrementThenLoad_relaxed() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a &- b + let result2: Int8 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_wrappingDecrementThenLoad_acquiring() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a &- b + let result2: Int8 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_wrappingDecrementThenLoad_releasing() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a &- b + let result2: Int8 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_wrappingDecrementThenLoad_acquiringAndReleasing() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a &- b + let result2: Int8 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_wrappingDecrementThenLoad_sequentiallyConsistent() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a &- b + let result2: Int8 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_bitwiseAndThenLoad_relaxed() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a & b + let result2: Int8 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_bitwiseAndThenLoad_acquiring() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a & b + let result2: Int8 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_bitwiseAndThenLoad_releasing() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a & b + let result2: Int8 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_bitwiseAndThenLoad_acquiringAndReleasing() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a & b + let result2: Int8 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_bitwiseAndThenLoad_sequentiallyConsistent() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a & b + let result2: Int8 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_bitwiseOrThenLoad_relaxed() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a | b + let result2: Int8 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_bitwiseOrThenLoad_acquiring() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a | b + let result2: Int8 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_bitwiseOrThenLoad_releasing() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a | b + let result2: Int8 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_bitwiseOrThenLoad_acquiringAndReleasing() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a | b + let result2: Int8 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_bitwiseOrThenLoad_sequentiallyConsistent() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a | b + let result2: Int8 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_bitwiseXorThenLoad_relaxed() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a ^ b + let result2: Int8 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_bitwiseXorThenLoad_acquiring() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a ^ b + let result2: Int8 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_bitwiseXorThenLoad_releasing() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a ^ b + let result2: Int8 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_bitwiseXorThenLoad_acquiringAndReleasing() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a ^ b + let result2: Int8 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int8_bitwiseXorThenLoad_sequentiallyConsistent() { + let a: Int8 = 3 + let b: Int8 = 8 + let c: Int8 = 12 + let result1: Int8 = a ^ b + let result2: Int8 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + + func test_Int16_create_destroy() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), 23) + } + + func test_Int16_load_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), 23) + } + func test_Int16_load_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .acquiring), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .acquiring), 23) + } + func test_Int16_load_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .sequentiallyConsistent), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .sequentiallyConsistent), 23) + } + + func test_Int16_store_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .relaxed) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .relaxed) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + func test_Int16_store_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .releasing) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .releasing) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + func test_Int16_store_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .sequentiallyConsistent) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .sequentiallyConsistent) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + + func test_Int16_exchange_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .relaxed), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .relaxed), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .relaxed), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_Int16_exchange_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .acquiring), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .acquiring), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .acquiring), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_Int16_exchange_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .releasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .releasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .releasing), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_Int16_exchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .acquiringAndReleasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .acquiringAndReleasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .acquiringAndReleasing), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_Int16_exchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .sequentiallyConsistent), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .sequentiallyConsistent), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .sequentiallyConsistent), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + + func test_Int16_compareExchange_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_compareExchange_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_compareExchange_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_compareExchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_compareExchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + + func test_Int16_compareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_compareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_compareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_compareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_compareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_compareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_compareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_compareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_compareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_compareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_compareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_compareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_compareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_compareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_compareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_weakCompareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_weakCompareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_weakCompareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_weakCompareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_weakCompareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_weakCompareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_weakCompareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_weakCompareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_weakCompareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_weakCompareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_weakCompareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_weakCompareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_weakCompareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int16_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + + +// Bool operations + + +// Integer operations + + func test_Int16_loadThenWrappingIncrement_relaxed() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a &+ b + let result2: Int16 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenWrappingIncrement_acquiring() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a &+ b + let result2: Int16 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenWrappingIncrement_releasing() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a &+ b + let result2: Int16 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenWrappingIncrement_acquiringAndReleasing() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a &+ b + let result2: Int16 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenWrappingIncrement_sequentiallyConsistent() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a &+ b + let result2: Int16 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenWrappingDecrement_relaxed() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a &- b + let result2: Int16 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenWrappingDecrement_acquiring() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a &- b + let result2: Int16 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenWrappingDecrement_releasing() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a &- b + let result2: Int16 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenWrappingDecrement_acquiringAndReleasing() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a &- b + let result2: Int16 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenWrappingDecrement_sequentiallyConsistent() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a &- b + let result2: Int16 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenBitwiseAnd_relaxed() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a & b + let result2: Int16 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenBitwiseAnd_acquiring() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a & b + let result2: Int16 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenBitwiseAnd_releasing() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a & b + let result2: Int16 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenBitwiseAnd_acquiringAndReleasing() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a & b + let result2: Int16 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenBitwiseAnd_sequentiallyConsistent() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a & b + let result2: Int16 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenBitwiseOr_relaxed() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a | b + let result2: Int16 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenBitwiseOr_acquiring() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a | b + let result2: Int16 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenBitwiseOr_releasing() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a | b + let result2: Int16 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenBitwiseOr_acquiringAndReleasing() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a | b + let result2: Int16 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenBitwiseOr_sequentiallyConsistent() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a | b + let result2: Int16 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenBitwiseXor_relaxed() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a ^ b + let result2: Int16 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenBitwiseXor_acquiring() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a ^ b + let result2: Int16 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenBitwiseXor_releasing() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a ^ b + let result2: Int16 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenBitwiseXor_acquiringAndReleasing() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a ^ b + let result2: Int16 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_loadThenBitwiseXor_sequentiallyConsistent() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a ^ b + let result2: Int16 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + + func test_Int16_wrappingIncrementThenLoad_relaxed() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a &+ b + let result2: Int16 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_wrappingIncrementThenLoad_acquiring() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a &+ b + let result2: Int16 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_wrappingIncrementThenLoad_releasing() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a &+ b + let result2: Int16 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_wrappingIncrementThenLoad_acquiringAndReleasing() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a &+ b + let result2: Int16 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_wrappingIncrementThenLoad_sequentiallyConsistent() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a &+ b + let result2: Int16 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_wrappingDecrementThenLoad_relaxed() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a &- b + let result2: Int16 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_wrappingDecrementThenLoad_acquiring() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a &- b + let result2: Int16 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_wrappingDecrementThenLoad_releasing() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a &- b + let result2: Int16 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_wrappingDecrementThenLoad_acquiringAndReleasing() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a &- b + let result2: Int16 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_wrappingDecrementThenLoad_sequentiallyConsistent() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a &- b + let result2: Int16 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_bitwiseAndThenLoad_relaxed() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a & b + let result2: Int16 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_bitwiseAndThenLoad_acquiring() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a & b + let result2: Int16 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_bitwiseAndThenLoad_releasing() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a & b + let result2: Int16 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_bitwiseAndThenLoad_acquiringAndReleasing() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a & b + let result2: Int16 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_bitwiseAndThenLoad_sequentiallyConsistent() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a & b + let result2: Int16 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_bitwiseOrThenLoad_relaxed() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a | b + let result2: Int16 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_bitwiseOrThenLoad_acquiring() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a | b + let result2: Int16 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_bitwiseOrThenLoad_releasing() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a | b + let result2: Int16 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_bitwiseOrThenLoad_acquiringAndReleasing() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a | b + let result2: Int16 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_bitwiseOrThenLoad_sequentiallyConsistent() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a | b + let result2: Int16 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_bitwiseXorThenLoad_relaxed() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a ^ b + let result2: Int16 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_bitwiseXorThenLoad_acquiring() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a ^ b + let result2: Int16 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_bitwiseXorThenLoad_releasing() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a ^ b + let result2: Int16 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_bitwiseXorThenLoad_acquiringAndReleasing() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a ^ b + let result2: Int16 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int16_bitwiseXorThenLoad_sequentiallyConsistent() { + let a: Int16 = 3 + let b: Int16 = 8 + let c: Int16 = 12 + let result1: Int16 = a ^ b + let result2: Int16 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + + func test_Int32_create_destroy() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), 23) + } + + func test_Int32_load_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), 23) + } + func test_Int32_load_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .acquiring), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .acquiring), 23) + } + func test_Int32_load_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .sequentiallyConsistent), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .sequentiallyConsistent), 23) + } + + func test_Int32_store_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .relaxed) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .relaxed) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + func test_Int32_store_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .releasing) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .releasing) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + func test_Int32_store_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .sequentiallyConsistent) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .sequentiallyConsistent) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + + func test_Int32_exchange_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .relaxed), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .relaxed), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .relaxed), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_Int32_exchange_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .acquiring), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .acquiring), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .acquiring), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_Int32_exchange_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .releasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .releasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .releasing), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_Int32_exchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .acquiringAndReleasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .acquiringAndReleasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .acquiringAndReleasing), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_Int32_exchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .sequentiallyConsistent), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .sequentiallyConsistent), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .sequentiallyConsistent), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + + func test_Int32_compareExchange_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_compareExchange_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_compareExchange_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_compareExchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_compareExchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + + func test_Int32_compareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_compareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_compareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_compareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_compareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_compareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_compareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_compareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_compareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_compareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_compareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_compareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_compareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_compareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_compareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_weakCompareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_weakCompareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_weakCompareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_weakCompareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_weakCompareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_weakCompareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_weakCompareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_weakCompareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_weakCompareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_weakCompareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_weakCompareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_weakCompareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_weakCompareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int32_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + + +// Bool operations + + +// Integer operations + + func test_Int32_loadThenWrappingIncrement_relaxed() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a &+ b + let result2: Int32 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenWrappingIncrement_acquiring() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a &+ b + let result2: Int32 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenWrappingIncrement_releasing() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a &+ b + let result2: Int32 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenWrappingIncrement_acquiringAndReleasing() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a &+ b + let result2: Int32 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenWrappingIncrement_sequentiallyConsistent() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a &+ b + let result2: Int32 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenWrappingDecrement_relaxed() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a &- b + let result2: Int32 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenWrappingDecrement_acquiring() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a &- b + let result2: Int32 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenWrappingDecrement_releasing() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a &- b + let result2: Int32 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenWrappingDecrement_acquiringAndReleasing() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a &- b + let result2: Int32 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenWrappingDecrement_sequentiallyConsistent() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a &- b + let result2: Int32 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenBitwiseAnd_relaxed() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a & b + let result2: Int32 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenBitwiseAnd_acquiring() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a & b + let result2: Int32 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenBitwiseAnd_releasing() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a & b + let result2: Int32 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenBitwiseAnd_acquiringAndReleasing() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a & b + let result2: Int32 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenBitwiseAnd_sequentiallyConsistent() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a & b + let result2: Int32 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenBitwiseOr_relaxed() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a | b + let result2: Int32 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenBitwiseOr_acquiring() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a | b + let result2: Int32 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenBitwiseOr_releasing() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a | b + let result2: Int32 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenBitwiseOr_acquiringAndReleasing() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a | b + let result2: Int32 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenBitwiseOr_sequentiallyConsistent() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a | b + let result2: Int32 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenBitwiseXor_relaxed() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a ^ b + let result2: Int32 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenBitwiseXor_acquiring() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a ^ b + let result2: Int32 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenBitwiseXor_releasing() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a ^ b + let result2: Int32 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenBitwiseXor_acquiringAndReleasing() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a ^ b + let result2: Int32 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_loadThenBitwiseXor_sequentiallyConsistent() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a ^ b + let result2: Int32 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + + func test_Int32_wrappingIncrementThenLoad_relaxed() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a &+ b + let result2: Int32 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_wrappingIncrementThenLoad_acquiring() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a &+ b + let result2: Int32 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_wrappingIncrementThenLoad_releasing() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a &+ b + let result2: Int32 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_wrappingIncrementThenLoad_acquiringAndReleasing() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a &+ b + let result2: Int32 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_wrappingIncrementThenLoad_sequentiallyConsistent() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a &+ b + let result2: Int32 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_wrappingDecrementThenLoad_relaxed() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a &- b + let result2: Int32 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_wrappingDecrementThenLoad_acquiring() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a &- b + let result2: Int32 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_wrappingDecrementThenLoad_releasing() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a &- b + let result2: Int32 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_wrappingDecrementThenLoad_acquiringAndReleasing() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a &- b + let result2: Int32 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_wrappingDecrementThenLoad_sequentiallyConsistent() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a &- b + let result2: Int32 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_bitwiseAndThenLoad_relaxed() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a & b + let result2: Int32 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_bitwiseAndThenLoad_acquiring() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a & b + let result2: Int32 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_bitwiseAndThenLoad_releasing() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a & b + let result2: Int32 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_bitwiseAndThenLoad_acquiringAndReleasing() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a & b + let result2: Int32 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_bitwiseAndThenLoad_sequentiallyConsistent() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a & b + let result2: Int32 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_bitwiseOrThenLoad_relaxed() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a | b + let result2: Int32 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_bitwiseOrThenLoad_acquiring() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a | b + let result2: Int32 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_bitwiseOrThenLoad_releasing() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a | b + let result2: Int32 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_bitwiseOrThenLoad_acquiringAndReleasing() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a | b + let result2: Int32 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_bitwiseOrThenLoad_sequentiallyConsistent() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a | b + let result2: Int32 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_bitwiseXorThenLoad_relaxed() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a ^ b + let result2: Int32 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_bitwiseXorThenLoad_acquiring() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a ^ b + let result2: Int32 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_bitwiseXorThenLoad_releasing() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a ^ b + let result2: Int32 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_bitwiseXorThenLoad_acquiringAndReleasing() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a ^ b + let result2: Int32 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int32_bitwiseXorThenLoad_sequentiallyConsistent() { + let a: Int32 = 3 + let b: Int32 = 8 + let c: Int32 = 12 + let result1: Int32 = a ^ b + let result2: Int32 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + + func test_Int64_create_destroy() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), 23) + } + + func test_Int64_load_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), 23) + } + func test_Int64_load_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .acquiring), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .acquiring), 23) + } + func test_Int64_load_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .sequentiallyConsistent), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .sequentiallyConsistent), 23) + } + + func test_Int64_store_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .relaxed) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .relaxed) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + func test_Int64_store_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .releasing) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .releasing) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + func test_Int64_store_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .sequentiallyConsistent) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .sequentiallyConsistent) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + + func test_Int64_exchange_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .relaxed), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .relaxed), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .relaxed), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_Int64_exchange_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .acquiring), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .acquiring), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .acquiring), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_Int64_exchange_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .releasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .releasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .releasing), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_Int64_exchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .acquiringAndReleasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .acquiringAndReleasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .acquiringAndReleasing), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_Int64_exchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .sequentiallyConsistent), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .sequentiallyConsistent), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .sequentiallyConsistent), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + + func test_Int64_compareExchange_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_compareExchange_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_compareExchange_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_compareExchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_compareExchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + + func test_Int64_compareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_compareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_compareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_compareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_compareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_compareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_compareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_compareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_compareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_compareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_compareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_compareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_compareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_compareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_compareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_weakCompareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_weakCompareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_weakCompareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_weakCompareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_weakCompareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_weakCompareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_weakCompareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_weakCompareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_weakCompareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_weakCompareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_weakCompareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_weakCompareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_weakCompareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_Int64_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + + +// Bool operations + + +// Integer operations + + func test_Int64_loadThenWrappingIncrement_relaxed() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a &+ b + let result2: Int64 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenWrappingIncrement_acquiring() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a &+ b + let result2: Int64 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenWrappingIncrement_releasing() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a &+ b + let result2: Int64 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenWrappingIncrement_acquiringAndReleasing() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a &+ b + let result2: Int64 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenWrappingIncrement_sequentiallyConsistent() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a &+ b + let result2: Int64 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenWrappingDecrement_relaxed() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a &- b + let result2: Int64 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenWrappingDecrement_acquiring() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a &- b + let result2: Int64 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenWrappingDecrement_releasing() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a &- b + let result2: Int64 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenWrappingDecrement_acquiringAndReleasing() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a &- b + let result2: Int64 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenWrappingDecrement_sequentiallyConsistent() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a &- b + let result2: Int64 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenBitwiseAnd_relaxed() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a & b + let result2: Int64 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenBitwiseAnd_acquiring() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a & b + let result2: Int64 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenBitwiseAnd_releasing() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a & b + let result2: Int64 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenBitwiseAnd_acquiringAndReleasing() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a & b + let result2: Int64 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenBitwiseAnd_sequentiallyConsistent() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a & b + let result2: Int64 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenBitwiseOr_relaxed() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a | b + let result2: Int64 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenBitwiseOr_acquiring() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a | b + let result2: Int64 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenBitwiseOr_releasing() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a | b + let result2: Int64 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenBitwiseOr_acquiringAndReleasing() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a | b + let result2: Int64 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenBitwiseOr_sequentiallyConsistent() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a | b + let result2: Int64 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenBitwiseXor_relaxed() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a ^ b + let result2: Int64 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenBitwiseXor_acquiring() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a ^ b + let result2: Int64 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenBitwiseXor_releasing() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a ^ b + let result2: Int64 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenBitwiseXor_acquiringAndReleasing() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a ^ b + let result2: Int64 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_loadThenBitwiseXor_sequentiallyConsistent() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a ^ b + let result2: Int64 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + + func test_Int64_wrappingIncrementThenLoad_relaxed() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a &+ b + let result2: Int64 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_wrappingIncrementThenLoad_acquiring() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a &+ b + let result2: Int64 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_wrappingIncrementThenLoad_releasing() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a &+ b + let result2: Int64 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_wrappingIncrementThenLoad_acquiringAndReleasing() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a &+ b + let result2: Int64 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_wrappingIncrementThenLoad_sequentiallyConsistent() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a &+ b + let result2: Int64 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_wrappingDecrementThenLoad_relaxed() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a &- b + let result2: Int64 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_wrappingDecrementThenLoad_acquiring() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a &- b + let result2: Int64 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_wrappingDecrementThenLoad_releasing() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a &- b + let result2: Int64 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_wrappingDecrementThenLoad_acquiringAndReleasing() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a &- b + let result2: Int64 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_wrappingDecrementThenLoad_sequentiallyConsistent() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a &- b + let result2: Int64 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_bitwiseAndThenLoad_relaxed() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a & b + let result2: Int64 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_bitwiseAndThenLoad_acquiring() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a & b + let result2: Int64 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_bitwiseAndThenLoad_releasing() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a & b + let result2: Int64 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_bitwiseAndThenLoad_acquiringAndReleasing() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a & b + let result2: Int64 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_bitwiseAndThenLoad_sequentiallyConsistent() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a & b + let result2: Int64 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_bitwiseOrThenLoad_relaxed() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a | b + let result2: Int64 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_bitwiseOrThenLoad_acquiring() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a | b + let result2: Int64 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_bitwiseOrThenLoad_releasing() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a | b + let result2: Int64 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_bitwiseOrThenLoad_acquiringAndReleasing() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a | b + let result2: Int64 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_bitwiseOrThenLoad_sequentiallyConsistent() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a | b + let result2: Int64 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_bitwiseXorThenLoad_relaxed() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a ^ b + let result2: Int64 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_bitwiseXorThenLoad_acquiring() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a ^ b + let result2: Int64 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_bitwiseXorThenLoad_releasing() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a ^ b + let result2: Int64 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_bitwiseXorThenLoad_acquiringAndReleasing() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a ^ b + let result2: Int64 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_Int64_bitwiseXorThenLoad_sequentiallyConsistent() { + let a: Int64 = 3 + let b: Int64 = 8 + let c: Int64 = 12 + let result1: Int64 = a ^ b + let result2: Int64 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + + func test_UInt_create_destroy() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), 23) + } + + func test_UInt_load_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), 23) + } + func test_UInt_load_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .acquiring), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .acquiring), 23) + } + func test_UInt_load_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .sequentiallyConsistent), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .sequentiallyConsistent), 23) + } + + func test_UInt_store_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .relaxed) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .relaxed) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + func test_UInt_store_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .releasing) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .releasing) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + func test_UInt_store_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .sequentiallyConsistent) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .sequentiallyConsistent) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + + func test_UInt_exchange_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .relaxed), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .relaxed), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .relaxed), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_UInt_exchange_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .acquiring), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .acquiring), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .acquiring), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_UInt_exchange_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .releasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .releasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .releasing), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_UInt_exchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .acquiringAndReleasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .acquiringAndReleasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .acquiringAndReleasing), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_UInt_exchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .sequentiallyConsistent), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .sequentiallyConsistent), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .sequentiallyConsistent), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + + func test_UInt_compareExchange_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_compareExchange_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_compareExchange_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_compareExchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_compareExchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + + func test_UInt_compareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_compareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_compareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_compareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_compareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_compareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_compareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_compareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_compareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_compareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_compareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_compareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_compareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_compareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_compareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_weakCompareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_weakCompareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_weakCompareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_weakCompareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_weakCompareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_weakCompareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_weakCompareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_weakCompareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_weakCompareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_weakCompareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_weakCompareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_weakCompareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_weakCompareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + + +// Bool operations + + +// Integer operations + + func test_UInt_loadThenWrappingIncrement_relaxed() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a &+ b + let result2: UInt = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenWrappingIncrement_acquiring() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a &+ b + let result2: UInt = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenWrappingIncrement_releasing() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a &+ b + let result2: UInt = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenWrappingIncrement_acquiringAndReleasing() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a &+ b + let result2: UInt = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenWrappingIncrement_sequentiallyConsistent() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a &+ b + let result2: UInt = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenWrappingDecrement_relaxed() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a &- b + let result2: UInt = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenWrappingDecrement_acquiring() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a &- b + let result2: UInt = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenWrappingDecrement_releasing() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a &- b + let result2: UInt = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenWrappingDecrement_acquiringAndReleasing() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a &- b + let result2: UInt = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenWrappingDecrement_sequentiallyConsistent() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a &- b + let result2: UInt = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenBitwiseAnd_relaxed() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a & b + let result2: UInt = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenBitwiseAnd_acquiring() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a & b + let result2: UInt = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenBitwiseAnd_releasing() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a & b + let result2: UInt = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenBitwiseAnd_acquiringAndReleasing() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a & b + let result2: UInt = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenBitwiseAnd_sequentiallyConsistent() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a & b + let result2: UInt = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenBitwiseOr_relaxed() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a | b + let result2: UInt = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenBitwiseOr_acquiring() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a | b + let result2: UInt = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenBitwiseOr_releasing() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a | b + let result2: UInt = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenBitwiseOr_acquiringAndReleasing() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a | b + let result2: UInt = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenBitwiseOr_sequentiallyConsistent() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a | b + let result2: UInt = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenBitwiseXor_relaxed() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a ^ b + let result2: UInt = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenBitwiseXor_acquiring() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a ^ b + let result2: UInt = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenBitwiseXor_releasing() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a ^ b + let result2: UInt = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenBitwiseXor_acquiringAndReleasing() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a ^ b + let result2: UInt = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_loadThenBitwiseXor_sequentiallyConsistent() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a ^ b + let result2: UInt = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + + func test_UInt_wrappingIncrementThenLoad_relaxed() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a &+ b + let result2: UInt = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_wrappingIncrementThenLoad_acquiring() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a &+ b + let result2: UInt = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_wrappingIncrementThenLoad_releasing() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a &+ b + let result2: UInt = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_wrappingIncrementThenLoad_acquiringAndReleasing() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a &+ b + let result2: UInt = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_wrappingIncrementThenLoad_sequentiallyConsistent() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a &+ b + let result2: UInt = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_wrappingDecrementThenLoad_relaxed() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a &- b + let result2: UInt = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_wrappingDecrementThenLoad_acquiring() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a &- b + let result2: UInt = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_wrappingDecrementThenLoad_releasing() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a &- b + let result2: UInt = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_wrappingDecrementThenLoad_acquiringAndReleasing() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a &- b + let result2: UInt = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_wrappingDecrementThenLoad_sequentiallyConsistent() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a &- b + let result2: UInt = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_bitwiseAndThenLoad_relaxed() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a & b + let result2: UInt = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_bitwiseAndThenLoad_acquiring() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a & b + let result2: UInt = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_bitwiseAndThenLoad_releasing() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a & b + let result2: UInt = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_bitwiseAndThenLoad_acquiringAndReleasing() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a & b + let result2: UInt = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_bitwiseAndThenLoad_sequentiallyConsistent() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a & b + let result2: UInt = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_bitwiseOrThenLoad_relaxed() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a | b + let result2: UInt = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_bitwiseOrThenLoad_acquiring() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a | b + let result2: UInt = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_bitwiseOrThenLoad_releasing() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a | b + let result2: UInt = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_bitwiseOrThenLoad_acquiringAndReleasing() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a | b + let result2: UInt = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_bitwiseOrThenLoad_sequentiallyConsistent() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a | b + let result2: UInt = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_bitwiseXorThenLoad_relaxed() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a ^ b + let result2: UInt = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_bitwiseXorThenLoad_acquiring() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a ^ b + let result2: UInt = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_bitwiseXorThenLoad_releasing() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a ^ b + let result2: UInt = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_bitwiseXorThenLoad_acquiringAndReleasing() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a ^ b + let result2: UInt = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt_bitwiseXorThenLoad_sequentiallyConsistent() { + let a: UInt = 3 + let b: UInt = 8 + let c: UInt = 12 + let result1: UInt = a ^ b + let result2: UInt = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + + func test_UInt8_create_destroy() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), 23) + } + + func test_UInt8_load_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), 23) + } + func test_UInt8_load_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .acquiring), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .acquiring), 23) + } + func test_UInt8_load_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .sequentiallyConsistent), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .sequentiallyConsistent), 23) + } + + func test_UInt8_store_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .relaxed) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .relaxed) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + func test_UInt8_store_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .releasing) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .releasing) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + func test_UInt8_store_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .sequentiallyConsistent) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .sequentiallyConsistent) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + + func test_UInt8_exchange_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .relaxed), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .relaxed), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .relaxed), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_UInt8_exchange_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .acquiring), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .acquiring), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .acquiring), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_UInt8_exchange_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .releasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .releasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .releasing), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_UInt8_exchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .acquiringAndReleasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .acquiringAndReleasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .acquiringAndReleasing), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_UInt8_exchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .sequentiallyConsistent), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .sequentiallyConsistent), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .sequentiallyConsistent), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + + func test_UInt8_compareExchange_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_compareExchange_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_compareExchange_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_compareExchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_compareExchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + + func test_UInt8_compareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_compareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_compareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_compareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_compareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_compareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_compareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_compareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_compareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_compareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_compareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_compareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_compareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_compareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_compareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_weakCompareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_weakCompareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_weakCompareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_weakCompareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_weakCompareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_weakCompareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_weakCompareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_weakCompareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_weakCompareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_weakCompareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_weakCompareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_weakCompareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_weakCompareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt8_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + + +// Bool operations + + +// Integer operations + + func test_UInt8_loadThenWrappingIncrement_relaxed() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a &+ b + let result2: UInt8 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenWrappingIncrement_acquiring() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a &+ b + let result2: UInt8 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenWrappingIncrement_releasing() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a &+ b + let result2: UInt8 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenWrappingIncrement_acquiringAndReleasing() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a &+ b + let result2: UInt8 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenWrappingIncrement_sequentiallyConsistent() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a &+ b + let result2: UInt8 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenWrappingDecrement_relaxed() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a &- b + let result2: UInt8 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenWrappingDecrement_acquiring() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a &- b + let result2: UInt8 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenWrappingDecrement_releasing() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a &- b + let result2: UInt8 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenWrappingDecrement_acquiringAndReleasing() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a &- b + let result2: UInt8 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenWrappingDecrement_sequentiallyConsistent() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a &- b + let result2: UInt8 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenBitwiseAnd_relaxed() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a & b + let result2: UInt8 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenBitwiseAnd_acquiring() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a & b + let result2: UInt8 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenBitwiseAnd_releasing() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a & b + let result2: UInt8 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenBitwiseAnd_acquiringAndReleasing() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a & b + let result2: UInt8 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenBitwiseAnd_sequentiallyConsistent() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a & b + let result2: UInt8 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenBitwiseOr_relaxed() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a | b + let result2: UInt8 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenBitwiseOr_acquiring() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a | b + let result2: UInt8 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenBitwiseOr_releasing() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a | b + let result2: UInt8 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenBitwiseOr_acquiringAndReleasing() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a | b + let result2: UInt8 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenBitwiseOr_sequentiallyConsistent() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a | b + let result2: UInt8 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenBitwiseXor_relaxed() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a ^ b + let result2: UInt8 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenBitwiseXor_acquiring() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a ^ b + let result2: UInt8 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenBitwiseXor_releasing() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a ^ b + let result2: UInt8 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenBitwiseXor_acquiringAndReleasing() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a ^ b + let result2: UInt8 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_loadThenBitwiseXor_sequentiallyConsistent() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a ^ b + let result2: UInt8 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + + func test_UInt8_wrappingIncrementThenLoad_relaxed() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a &+ b + let result2: UInt8 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_wrappingIncrementThenLoad_acquiring() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a &+ b + let result2: UInt8 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_wrappingIncrementThenLoad_releasing() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a &+ b + let result2: UInt8 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_wrappingIncrementThenLoad_acquiringAndReleasing() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a &+ b + let result2: UInt8 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_wrappingIncrementThenLoad_sequentiallyConsistent() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a &+ b + let result2: UInt8 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_wrappingDecrementThenLoad_relaxed() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a &- b + let result2: UInt8 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_wrappingDecrementThenLoad_acquiring() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a &- b + let result2: UInt8 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_wrappingDecrementThenLoad_releasing() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a &- b + let result2: UInt8 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_wrappingDecrementThenLoad_acquiringAndReleasing() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a &- b + let result2: UInt8 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_wrappingDecrementThenLoad_sequentiallyConsistent() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a &- b + let result2: UInt8 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_bitwiseAndThenLoad_relaxed() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a & b + let result2: UInt8 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_bitwiseAndThenLoad_acquiring() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a & b + let result2: UInt8 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_bitwiseAndThenLoad_releasing() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a & b + let result2: UInt8 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_bitwiseAndThenLoad_acquiringAndReleasing() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a & b + let result2: UInt8 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_bitwiseAndThenLoad_sequentiallyConsistent() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a & b + let result2: UInt8 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_bitwiseOrThenLoad_relaxed() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a | b + let result2: UInt8 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_bitwiseOrThenLoad_acquiring() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a | b + let result2: UInt8 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_bitwiseOrThenLoad_releasing() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a | b + let result2: UInt8 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_bitwiseOrThenLoad_acquiringAndReleasing() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a | b + let result2: UInt8 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_bitwiseOrThenLoad_sequentiallyConsistent() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a | b + let result2: UInt8 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_bitwiseXorThenLoad_relaxed() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a ^ b + let result2: UInt8 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_bitwiseXorThenLoad_acquiring() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a ^ b + let result2: UInt8 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_bitwiseXorThenLoad_releasing() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a ^ b + let result2: UInt8 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_bitwiseXorThenLoad_acquiringAndReleasing() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a ^ b + let result2: UInt8 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt8_bitwiseXorThenLoad_sequentiallyConsistent() { + let a: UInt8 = 3 + let b: UInt8 = 8 + let c: UInt8 = 12 + let result1: UInt8 = a ^ b + let result2: UInt8 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + + func test_UInt16_create_destroy() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), 23) + } + + func test_UInt16_load_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), 23) + } + func test_UInt16_load_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .acquiring), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .acquiring), 23) + } + func test_UInt16_load_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .sequentiallyConsistent), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .sequentiallyConsistent), 23) + } + + func test_UInt16_store_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .relaxed) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .relaxed) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + func test_UInt16_store_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .releasing) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .releasing) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + func test_UInt16_store_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .sequentiallyConsistent) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .sequentiallyConsistent) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + + func test_UInt16_exchange_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .relaxed), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .relaxed), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .relaxed), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_UInt16_exchange_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .acquiring), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .acquiring), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .acquiring), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_UInt16_exchange_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .releasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .releasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .releasing), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_UInt16_exchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .acquiringAndReleasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .acquiringAndReleasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .acquiringAndReleasing), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_UInt16_exchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .sequentiallyConsistent), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .sequentiallyConsistent), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .sequentiallyConsistent), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + + func test_UInt16_compareExchange_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_compareExchange_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_compareExchange_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_compareExchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_compareExchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + + func test_UInt16_compareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_compareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_compareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_compareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_compareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_compareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_compareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_compareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_compareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_compareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_compareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_compareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_compareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_compareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_compareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_weakCompareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_weakCompareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_weakCompareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_weakCompareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_weakCompareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_weakCompareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_weakCompareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_weakCompareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_weakCompareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_weakCompareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_weakCompareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_weakCompareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_weakCompareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt16_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + + +// Bool operations + + +// Integer operations + + func test_UInt16_loadThenWrappingIncrement_relaxed() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a &+ b + let result2: UInt16 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenWrappingIncrement_acquiring() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a &+ b + let result2: UInt16 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenWrappingIncrement_releasing() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a &+ b + let result2: UInt16 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenWrappingIncrement_acquiringAndReleasing() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a &+ b + let result2: UInt16 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenWrappingIncrement_sequentiallyConsistent() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a &+ b + let result2: UInt16 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenWrappingDecrement_relaxed() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a &- b + let result2: UInt16 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenWrappingDecrement_acquiring() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a &- b + let result2: UInt16 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenWrappingDecrement_releasing() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a &- b + let result2: UInt16 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenWrappingDecrement_acquiringAndReleasing() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a &- b + let result2: UInt16 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenWrappingDecrement_sequentiallyConsistent() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a &- b + let result2: UInt16 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenBitwiseAnd_relaxed() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a & b + let result2: UInt16 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenBitwiseAnd_acquiring() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a & b + let result2: UInt16 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenBitwiseAnd_releasing() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a & b + let result2: UInt16 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenBitwiseAnd_acquiringAndReleasing() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a & b + let result2: UInt16 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenBitwiseAnd_sequentiallyConsistent() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a & b + let result2: UInt16 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenBitwiseOr_relaxed() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a | b + let result2: UInt16 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenBitwiseOr_acquiring() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a | b + let result2: UInt16 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenBitwiseOr_releasing() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a | b + let result2: UInt16 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenBitwiseOr_acquiringAndReleasing() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a | b + let result2: UInt16 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenBitwiseOr_sequentiallyConsistent() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a | b + let result2: UInt16 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenBitwiseXor_relaxed() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a ^ b + let result2: UInt16 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenBitwiseXor_acquiring() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a ^ b + let result2: UInt16 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenBitwiseXor_releasing() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a ^ b + let result2: UInt16 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenBitwiseXor_acquiringAndReleasing() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a ^ b + let result2: UInt16 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_loadThenBitwiseXor_sequentiallyConsistent() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a ^ b + let result2: UInt16 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + + func test_UInt16_wrappingIncrementThenLoad_relaxed() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a &+ b + let result2: UInt16 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_wrappingIncrementThenLoad_acquiring() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a &+ b + let result2: UInt16 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_wrappingIncrementThenLoad_releasing() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a &+ b + let result2: UInt16 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_wrappingIncrementThenLoad_acquiringAndReleasing() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a &+ b + let result2: UInt16 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_wrappingIncrementThenLoad_sequentiallyConsistent() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a &+ b + let result2: UInt16 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_wrappingDecrementThenLoad_relaxed() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a &- b + let result2: UInt16 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_wrappingDecrementThenLoad_acquiring() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a &- b + let result2: UInt16 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_wrappingDecrementThenLoad_releasing() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a &- b + let result2: UInt16 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_wrappingDecrementThenLoad_acquiringAndReleasing() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a &- b + let result2: UInt16 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_wrappingDecrementThenLoad_sequentiallyConsistent() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a &- b + let result2: UInt16 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_bitwiseAndThenLoad_relaxed() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a & b + let result2: UInt16 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_bitwiseAndThenLoad_acquiring() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a & b + let result2: UInt16 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_bitwiseAndThenLoad_releasing() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a & b + let result2: UInt16 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_bitwiseAndThenLoad_acquiringAndReleasing() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a & b + let result2: UInt16 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_bitwiseAndThenLoad_sequentiallyConsistent() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a & b + let result2: UInt16 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_bitwiseOrThenLoad_relaxed() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a | b + let result2: UInt16 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_bitwiseOrThenLoad_acquiring() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a | b + let result2: UInt16 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_bitwiseOrThenLoad_releasing() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a | b + let result2: UInt16 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_bitwiseOrThenLoad_acquiringAndReleasing() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a | b + let result2: UInt16 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_bitwiseOrThenLoad_sequentiallyConsistent() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a | b + let result2: UInt16 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_bitwiseXorThenLoad_relaxed() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a ^ b + let result2: UInt16 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_bitwiseXorThenLoad_acquiring() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a ^ b + let result2: UInt16 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_bitwiseXorThenLoad_releasing() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a ^ b + let result2: UInt16 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_bitwiseXorThenLoad_acquiringAndReleasing() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a ^ b + let result2: UInt16 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt16_bitwiseXorThenLoad_sequentiallyConsistent() { + let a: UInt16 = 3 + let b: UInt16 = 8 + let c: UInt16 = 12 + let result1: UInt16 = a ^ b + let result2: UInt16 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + + func test_UInt32_create_destroy() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), 23) + } + + func test_UInt32_load_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), 23) + } + func test_UInt32_load_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .acquiring), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .acquiring), 23) + } + func test_UInt32_load_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .sequentiallyConsistent), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .sequentiallyConsistent), 23) + } + + func test_UInt32_store_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .relaxed) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .relaxed) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + func test_UInt32_store_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .releasing) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .releasing) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + func test_UInt32_store_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .sequentiallyConsistent) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .sequentiallyConsistent) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + + func test_UInt32_exchange_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .relaxed), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .relaxed), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .relaxed), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_UInt32_exchange_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .acquiring), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .acquiring), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .acquiring), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_UInt32_exchange_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .releasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .releasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .releasing), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_UInt32_exchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .acquiringAndReleasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .acquiringAndReleasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .acquiringAndReleasing), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_UInt32_exchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .sequentiallyConsistent), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .sequentiallyConsistent), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .sequentiallyConsistent), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + + func test_UInt32_compareExchange_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_compareExchange_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_compareExchange_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_compareExchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_compareExchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + + func test_UInt32_compareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_compareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_compareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_compareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_compareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_compareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_compareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_compareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_compareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_compareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_compareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_compareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_compareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_compareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_compareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_weakCompareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_weakCompareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_weakCompareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_weakCompareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_weakCompareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_weakCompareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_weakCompareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_weakCompareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_weakCompareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_weakCompareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_weakCompareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_weakCompareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_weakCompareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt32_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + + +// Bool operations + + +// Integer operations + + func test_UInt32_loadThenWrappingIncrement_relaxed() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a &+ b + let result2: UInt32 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenWrappingIncrement_acquiring() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a &+ b + let result2: UInt32 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenWrappingIncrement_releasing() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a &+ b + let result2: UInt32 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenWrappingIncrement_acquiringAndReleasing() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a &+ b + let result2: UInt32 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenWrappingIncrement_sequentiallyConsistent() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a &+ b + let result2: UInt32 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenWrappingDecrement_relaxed() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a &- b + let result2: UInt32 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenWrappingDecrement_acquiring() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a &- b + let result2: UInt32 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenWrappingDecrement_releasing() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a &- b + let result2: UInt32 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenWrappingDecrement_acquiringAndReleasing() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a &- b + let result2: UInt32 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenWrappingDecrement_sequentiallyConsistent() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a &- b + let result2: UInt32 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenBitwiseAnd_relaxed() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a & b + let result2: UInt32 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenBitwiseAnd_acquiring() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a & b + let result2: UInt32 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenBitwiseAnd_releasing() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a & b + let result2: UInt32 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenBitwiseAnd_acquiringAndReleasing() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a & b + let result2: UInt32 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenBitwiseAnd_sequentiallyConsistent() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a & b + let result2: UInt32 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenBitwiseOr_relaxed() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a | b + let result2: UInt32 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenBitwiseOr_acquiring() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a | b + let result2: UInt32 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenBitwiseOr_releasing() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a | b + let result2: UInt32 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenBitwiseOr_acquiringAndReleasing() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a | b + let result2: UInt32 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenBitwiseOr_sequentiallyConsistent() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a | b + let result2: UInt32 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenBitwiseXor_relaxed() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a ^ b + let result2: UInt32 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenBitwiseXor_acquiring() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a ^ b + let result2: UInt32 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenBitwiseXor_releasing() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a ^ b + let result2: UInt32 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenBitwiseXor_acquiringAndReleasing() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a ^ b + let result2: UInt32 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_loadThenBitwiseXor_sequentiallyConsistent() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a ^ b + let result2: UInt32 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + + func test_UInt32_wrappingIncrementThenLoad_relaxed() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a &+ b + let result2: UInt32 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_wrappingIncrementThenLoad_acquiring() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a &+ b + let result2: UInt32 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_wrappingIncrementThenLoad_releasing() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a &+ b + let result2: UInt32 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_wrappingIncrementThenLoad_acquiringAndReleasing() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a &+ b + let result2: UInt32 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_wrappingIncrementThenLoad_sequentiallyConsistent() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a &+ b + let result2: UInt32 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_wrappingDecrementThenLoad_relaxed() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a &- b + let result2: UInt32 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_wrappingDecrementThenLoad_acquiring() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a &- b + let result2: UInt32 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_wrappingDecrementThenLoad_releasing() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a &- b + let result2: UInt32 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_wrappingDecrementThenLoad_acquiringAndReleasing() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a &- b + let result2: UInt32 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_wrappingDecrementThenLoad_sequentiallyConsistent() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a &- b + let result2: UInt32 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_bitwiseAndThenLoad_relaxed() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a & b + let result2: UInt32 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_bitwiseAndThenLoad_acquiring() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a & b + let result2: UInt32 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_bitwiseAndThenLoad_releasing() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a & b + let result2: UInt32 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_bitwiseAndThenLoad_acquiringAndReleasing() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a & b + let result2: UInt32 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_bitwiseAndThenLoad_sequentiallyConsistent() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a & b + let result2: UInt32 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_bitwiseOrThenLoad_relaxed() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a | b + let result2: UInt32 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_bitwiseOrThenLoad_acquiring() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a | b + let result2: UInt32 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_bitwiseOrThenLoad_releasing() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a | b + let result2: UInt32 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_bitwiseOrThenLoad_acquiringAndReleasing() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a | b + let result2: UInt32 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_bitwiseOrThenLoad_sequentiallyConsistent() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a | b + let result2: UInt32 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_bitwiseXorThenLoad_relaxed() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a ^ b + let result2: UInt32 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_bitwiseXorThenLoad_acquiring() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a ^ b + let result2: UInt32 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_bitwiseXorThenLoad_releasing() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a ^ b + let result2: UInt32 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_bitwiseXorThenLoad_acquiringAndReleasing() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a ^ b + let result2: UInt32 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt32_bitwiseXorThenLoad_sequentiallyConsistent() { + let a: UInt32 = 3 + let b: UInt32 = 8 + let c: UInt32 = 12 + let result1: UInt32 = a ^ b + let result2: UInt32 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + + func test_UInt64_create_destroy() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), 23) + } + + func test_UInt64_load_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), 23) + } + func test_UInt64_load_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .acquiring), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .acquiring), 23) + } + func test_UInt64_load_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .sequentiallyConsistent), 12) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .sequentiallyConsistent), 23) + } + + func test_UInt64_store_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .relaxed) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .relaxed) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + func test_UInt64_store_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .releasing) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .releasing) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + func test_UInt64_store_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + v.store(23, ordering: .sequentiallyConsistent) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + let w = UnsafeAtomic.create(23) + defer { w.destroy() } + w.store(12, ordering: .sequentiallyConsistent) + XCTAssertEqual(w.load(ordering: .relaxed), 12) + } + + func test_UInt64_exchange_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .relaxed), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .relaxed), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .relaxed), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_UInt64_exchange_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .acquiring), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .acquiring), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .acquiring), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_UInt64_exchange_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .releasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .releasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .releasing), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_UInt64_exchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .acquiringAndReleasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .acquiringAndReleasing), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .acquiringAndReleasing), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + func test_UInt64_exchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(12, ordering: .sequentiallyConsistent), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + XCTAssertEqual(v.exchange(23, ordering: .sequentiallyConsistent), 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + XCTAssertEqual(v.exchange(23, ordering: .sequentiallyConsistent), 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + } + + func test_UInt64_compareExchange_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_compareExchange_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_compareExchange_releasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_compareExchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_compareExchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + + func test_UInt64_compareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_compareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_compareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_compareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_compareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_compareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_compareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_compareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_compareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_compareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_compareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_compareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_compareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_compareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_compareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_weakCompareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_weakCompareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_weakCompareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_weakCompareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_weakCompareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_weakCompareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_weakCompareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_weakCompareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_weakCompareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_weakCompareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_weakCompareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_weakCompareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_weakCompareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + func test_UInt64_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(12) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 12, + desired: 23, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 23) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, 23) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + + (exchanged, original) = v.compareExchange( + expected: 23, + desired: 12, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, 12) + XCTAssertEqual(v.load(ordering: .relaxed), 12) + } + + +// Bool operations + + +// Integer operations + + func test_UInt64_loadThenWrappingIncrement_relaxed() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a &+ b + let result2: UInt64 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenWrappingIncrement_acquiring() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a &+ b + let result2: UInt64 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenWrappingIncrement_releasing() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a &+ b + let result2: UInt64 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenWrappingIncrement_acquiringAndReleasing() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a &+ b + let result2: UInt64 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenWrappingIncrement_sequentiallyConsistent() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a &+ b + let result2: UInt64 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingIncrement(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingIncrement(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenWrappingDecrement_relaxed() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a &- b + let result2: UInt64 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenWrappingDecrement_acquiring() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a &- b + let result2: UInt64 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenWrappingDecrement_releasing() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a &- b + let result2: UInt64 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenWrappingDecrement_acquiringAndReleasing() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a &- b + let result2: UInt64 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenWrappingDecrement_sequentiallyConsistent() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a &- b + let result2: UInt64 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenWrappingDecrement(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenWrappingDecrement(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenBitwiseAnd_relaxed() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a & b + let result2: UInt64 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenBitwiseAnd_acquiring() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a & b + let result2: UInt64 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenBitwiseAnd_releasing() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a & b + let result2: UInt64 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenBitwiseAnd_acquiringAndReleasing() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a & b + let result2: UInt64 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenBitwiseAnd_sequentiallyConsistent() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a & b + let result2: UInt64 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseAnd(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseAnd(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenBitwiseOr_relaxed() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a | b + let result2: UInt64 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenBitwiseOr_acquiring() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a | b + let result2: UInt64 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenBitwiseOr_releasing() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a | b + let result2: UInt64 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenBitwiseOr_acquiringAndReleasing() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a | b + let result2: UInt64 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenBitwiseOr_sequentiallyConsistent() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a | b + let result2: UInt64 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseOr(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseOr(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenBitwiseXor_relaxed() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a ^ b + let result2: UInt64 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .relaxed) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .relaxed) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenBitwiseXor_acquiring() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a ^ b + let result2: UInt64 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .acquiring) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .acquiring) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenBitwiseXor_releasing() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a ^ b + let result2: UInt64 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .releasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .releasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenBitwiseXor_acquiringAndReleasing() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a ^ b + let result2: UInt64 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_loadThenBitwiseXor_sequentiallyConsistent() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a ^ b + let result2: UInt64 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let old1 = v.loadThenBitwiseXor(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(old1, a) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let old2 = v.loadThenBitwiseXor(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(old2, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + + func test_UInt64_wrappingIncrementThenLoad_relaxed() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a &+ b + let result2: UInt64 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_wrappingIncrementThenLoad_acquiring() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a &+ b + let result2: UInt64 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_wrappingIncrementThenLoad_releasing() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a &+ b + let result2: UInt64 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_wrappingIncrementThenLoad_acquiringAndReleasing() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a &+ b + let result2: UInt64 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_wrappingIncrementThenLoad_sequentiallyConsistent() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a &+ b + let result2: UInt64 = result1 &+ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingIncrementThenLoad(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingIncrementThenLoad(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_wrappingDecrementThenLoad_relaxed() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a &- b + let result2: UInt64 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_wrappingDecrementThenLoad_acquiring() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a &- b + let result2: UInt64 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_wrappingDecrementThenLoad_releasing() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a &- b + let result2: UInt64 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_wrappingDecrementThenLoad_acquiringAndReleasing() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a &- b + let result2: UInt64 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_wrappingDecrementThenLoad_sequentiallyConsistent() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a &- b + let result2: UInt64 = result1 &- c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.wrappingDecrementThenLoad(by: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.wrappingDecrementThenLoad(by: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_bitwiseAndThenLoad_relaxed() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a & b + let result2: UInt64 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_bitwiseAndThenLoad_acquiring() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a & b + let result2: UInt64 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_bitwiseAndThenLoad_releasing() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a & b + let result2: UInt64 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_bitwiseAndThenLoad_acquiringAndReleasing() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a & b + let result2: UInt64 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_bitwiseAndThenLoad_sequentiallyConsistent() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a & b + let result2: UInt64 = result1 & c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseAndThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseAndThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_bitwiseOrThenLoad_relaxed() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a | b + let result2: UInt64 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_bitwiseOrThenLoad_acquiring() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a | b + let result2: UInt64 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_bitwiseOrThenLoad_releasing() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a | b + let result2: UInt64 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_bitwiseOrThenLoad_acquiringAndReleasing() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a | b + let result2: UInt64 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_bitwiseOrThenLoad_sequentiallyConsistent() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a | b + let result2: UInt64 = result1 | c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseOrThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseOrThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_bitwiseXorThenLoad_relaxed() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a ^ b + let result2: UInt64 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .relaxed) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .relaxed) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_bitwiseXorThenLoad_acquiring() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a ^ b + let result2: UInt64 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .acquiring) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .acquiring) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_bitwiseXorThenLoad_releasing() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a ^ b + let result2: UInt64 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .releasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .releasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_bitwiseXorThenLoad_acquiringAndReleasing() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a ^ b + let result2: UInt64 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .acquiringAndReleasing) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + func test_UInt64_bitwiseXorThenLoad_sequentiallyConsistent() { + let a: UInt64 = 3 + let b: UInt64 = 8 + let c: UInt64 = 12 + let result1: UInt64 = a ^ b + let result2: UInt64 = result1 ^ c + + let v = UnsafeAtomic.create(a) + defer { v.destroy() } + + let new1 = v.bitwiseXorThenLoad(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(new1, result1) + XCTAssertEqual(v.load(ordering: .relaxed), result1) + + let new2 = v.bitwiseXorThenLoad(with: c, ordering: .sequentiallyConsistent) + XCTAssertEqual(new2, result2) + XCTAssertEqual(v.load(ordering: .relaxed), result2) + } + + func test_Bool_create_destroy() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), true) + + let w = UnsafeAtomic.create(false) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), false) + } + + func test_Bool_load_relaxed() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), true) + + let w = UnsafeAtomic.create(false) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), false) + } + func test_Bool_load_acquiring() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .acquiring), true) + + let w = UnsafeAtomic.create(false) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .acquiring), false) + } + func test_Bool_load_sequentiallyConsistent() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .sequentiallyConsistent), true) + + let w = UnsafeAtomic.create(false) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .sequentiallyConsistent), false) + } + + func test_Bool_store_relaxed() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + v.store(false, ordering: .relaxed) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + let w = UnsafeAtomic.create(false) + defer { w.destroy() } + w.store(true, ordering: .relaxed) + XCTAssertEqual(w.load(ordering: .relaxed), true) + } + func test_Bool_store_releasing() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + v.store(false, ordering: .releasing) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + let w = UnsafeAtomic.create(false) + defer { w.destroy() } + w.store(true, ordering: .releasing) + XCTAssertEqual(w.load(ordering: .relaxed), true) + } + func test_Bool_store_sequentiallyConsistent() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + v.store(false, ordering: .sequentiallyConsistent) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + let w = UnsafeAtomic.create(false) + defer { w.destroy() } + w.store(true, ordering: .sequentiallyConsistent) + XCTAssertEqual(w.load(ordering: .relaxed), true) + } + + func test_Bool_exchange_relaxed() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(true, ordering: .relaxed), true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + XCTAssertEqual(v.exchange(false, ordering: .relaxed), true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + XCTAssertEqual(v.exchange(false, ordering: .relaxed), false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + } + func test_Bool_exchange_acquiring() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(true, ordering: .acquiring), true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + XCTAssertEqual(v.exchange(false, ordering: .acquiring), true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + XCTAssertEqual(v.exchange(false, ordering: .acquiring), false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + } + func test_Bool_exchange_releasing() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(true, ordering: .releasing), true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + XCTAssertEqual(v.exchange(false, ordering: .releasing), true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + XCTAssertEqual(v.exchange(false, ordering: .releasing), false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + } + func test_Bool_exchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(true, ordering: .acquiringAndReleasing), true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + XCTAssertEqual(v.exchange(false, ordering: .acquiringAndReleasing), true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + XCTAssertEqual(v.exchange(false, ordering: .acquiringAndReleasing), false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + } + func test_Bool_exchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(true, ordering: .sequentiallyConsistent), true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + XCTAssertEqual(v.exchange(false, ordering: .sequentiallyConsistent), true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + XCTAssertEqual(v.exchange(false, ordering: .sequentiallyConsistent), false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + } + + func test_Bool_compareExchange_relaxed() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_compareExchange_acquiring() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_compareExchange_releasing() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_compareExchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_compareExchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + + func test_Bool_compareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_compareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_compareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_compareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_compareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_compareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_compareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_compareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_compareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_compareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_compareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_compareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_compareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_compareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_compareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_weakCompareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_weakCompareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_weakCompareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_weakCompareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_weakCompareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_weakCompareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_weakCompareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_weakCompareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_weakCompareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_weakCompareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_weakCompareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_weakCompareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_weakCompareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + func test_Bool_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(true) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: true, + desired: false, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), false) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, false) + XCTAssertEqual(v.load(ordering: .relaxed), true) + + (exchanged, original) = v.compareExchange( + expected: false, + desired: true, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, true) + XCTAssertEqual(v.load(ordering: .relaxed), true) + } + + +// Bool operations + + func test_Bool_loadThenLogicalAnd_relaxed() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.loadThenLogicalAnd(with: b, ordering: .relaxed) + XCTAssertEqual(r, a, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a && b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_loadThenLogicalAnd_acquiring() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.loadThenLogicalAnd(with: b, ordering: .acquiring) + XCTAssertEqual(r, a, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a && b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_loadThenLogicalAnd_releasing() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.loadThenLogicalAnd(with: b, ordering: .releasing) + XCTAssertEqual(r, a, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a && b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_loadThenLogicalAnd_acquiringAndReleasing() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.loadThenLogicalAnd(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(r, a, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a && b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_loadThenLogicalAnd_sequentiallyConsistent() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.loadThenLogicalAnd(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(r, a, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a && b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_loadThenLogicalOr_relaxed() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.loadThenLogicalOr(with: b, ordering: .relaxed) + XCTAssertEqual(r, a, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a || b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_loadThenLogicalOr_acquiring() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.loadThenLogicalOr(with: b, ordering: .acquiring) + XCTAssertEqual(r, a, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a || b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_loadThenLogicalOr_releasing() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.loadThenLogicalOr(with: b, ordering: .releasing) + XCTAssertEqual(r, a, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a || b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_loadThenLogicalOr_acquiringAndReleasing() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.loadThenLogicalOr(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(r, a, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a || b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_loadThenLogicalOr_sequentiallyConsistent() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.loadThenLogicalOr(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(r, a, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a || b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_loadThenLogicalXor_relaxed() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.loadThenLogicalXor(with: b, ordering: .relaxed) + XCTAssertEqual(r, a, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a != b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_loadThenLogicalXor_acquiring() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.loadThenLogicalXor(with: b, ordering: .acquiring) + XCTAssertEqual(r, a, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a != b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_loadThenLogicalXor_releasing() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.loadThenLogicalXor(with: b, ordering: .releasing) + XCTAssertEqual(r, a, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a != b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_loadThenLogicalXor_acquiringAndReleasing() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.loadThenLogicalXor(with: b, ordering: .acquiringAndReleasing) + XCTAssertEqual(r, a, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a != b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_loadThenLogicalXor_sequentiallyConsistent() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.loadThenLogicalXor(with: b, ordering: .sequentiallyConsistent) + XCTAssertEqual(r, a, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a != b, + "a = \(a), b =\(b)") + } + } + } + + func test_Bool_logicalAndThenLoad_relaxed() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.logicalAndThenLoad( + with: b, + ordering: .relaxed) + XCTAssertEqual(r, a && b, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a && b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_logicalAndThenLoad_acquiring() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.logicalAndThenLoad( + with: b, + ordering: .acquiring) + XCTAssertEqual(r, a && b, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a && b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_logicalAndThenLoad_releasing() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.logicalAndThenLoad( + with: b, + ordering: .releasing) + XCTAssertEqual(r, a && b, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a && b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_logicalAndThenLoad_acquiringAndReleasing() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.logicalAndThenLoad( + with: b, + ordering: .acquiringAndReleasing) + XCTAssertEqual(r, a && b, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a && b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_logicalAndThenLoad_sequentiallyConsistent() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.logicalAndThenLoad( + with: b, + ordering: .sequentiallyConsistent) + XCTAssertEqual(r, a && b, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a && b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_logicalOrThenLoad_relaxed() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.logicalOrThenLoad( + with: b, + ordering: .relaxed) + XCTAssertEqual(r, a || b, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a || b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_logicalOrThenLoad_acquiring() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.logicalOrThenLoad( + with: b, + ordering: .acquiring) + XCTAssertEqual(r, a || b, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a || b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_logicalOrThenLoad_releasing() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.logicalOrThenLoad( + with: b, + ordering: .releasing) + XCTAssertEqual(r, a || b, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a || b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_logicalOrThenLoad_acquiringAndReleasing() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.logicalOrThenLoad( + with: b, + ordering: .acquiringAndReleasing) + XCTAssertEqual(r, a || b, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a || b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_logicalOrThenLoad_sequentiallyConsistent() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.logicalOrThenLoad( + with: b, + ordering: .sequentiallyConsistent) + XCTAssertEqual(r, a || b, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a || b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_logicalXorThenLoad_relaxed() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.logicalXorThenLoad( + with: b, + ordering: .relaxed) + XCTAssertEqual(r, a != b, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a != b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_logicalXorThenLoad_acquiring() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.logicalXorThenLoad( + with: b, + ordering: .acquiring) + XCTAssertEqual(r, a != b, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a != b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_logicalXorThenLoad_releasing() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.logicalXorThenLoad( + with: b, + ordering: .releasing) + XCTAssertEqual(r, a != b, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a != b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_logicalXorThenLoad_acquiringAndReleasing() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.logicalXorThenLoad( + with: b, + ordering: .acquiringAndReleasing) + XCTAssertEqual(r, a != b, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a != b, + "a = \(a), b =\(b)") + } + } + } + func test_Bool_logicalXorThenLoad_sequentiallyConsistent() { + let v = UnsafeAtomic.create(false) + defer { v.destroy() } + + // The truth tables are super tiny, so just check every value + for a in [false, true] { + for b in [false, true] { + v.store(a, ordering: .relaxed) + let r = v.logicalXorThenLoad( + with: b, + ordering: .sequentiallyConsistent) + XCTAssertEqual(r, a != b, "a = \(a), b = \(b)") + XCTAssertEqual( + v.load(ordering: .relaxed), + a != b, + "a = \(a), b =\(b)") + } + } + } + +// Integer operations + + + func test_DoubleWord_create_destroy() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + let w = UnsafeAtomic.create(DoubleWord(high: 50, low: 32)) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + } + + func test_DoubleWord_load_relaxed() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + let w = UnsafeAtomic.create(DoubleWord(high: 50, low: 32)) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + } + func test_DoubleWord_load_acquiring() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .acquiring), DoubleWord(high: 100, low: 64)) + + let w = UnsafeAtomic.create(DoubleWord(high: 50, low: 32)) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .acquiring), DoubleWord(high: 50, low: 32)) + } + func test_DoubleWord_load_sequentiallyConsistent() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .sequentiallyConsistent), DoubleWord(high: 100, low: 64)) + + let w = UnsafeAtomic.create(DoubleWord(high: 50, low: 32)) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .sequentiallyConsistent), DoubleWord(high: 50, low: 32)) + } + + func test_DoubleWord_store_relaxed() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + v.store(DoubleWord(high: 50, low: 32), ordering: .relaxed) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + let w = UnsafeAtomic.create(DoubleWord(high: 50, low: 32)) + defer { w.destroy() } + w.store(DoubleWord(high: 100, low: 64), ordering: .relaxed) + XCTAssertEqual(w.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_store_releasing() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + v.store(DoubleWord(high: 50, low: 32), ordering: .releasing) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + let w = UnsafeAtomic.create(DoubleWord(high: 50, low: 32)) + defer { w.destroy() } + w.store(DoubleWord(high: 100, low: 64), ordering: .releasing) + XCTAssertEqual(w.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_store_sequentiallyConsistent() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + v.store(DoubleWord(high: 50, low: 32), ordering: .sequentiallyConsistent) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + let w = UnsafeAtomic.create(DoubleWord(high: 50, low: 32)) + defer { w.destroy() } + w.store(DoubleWord(high: 100, low: 64), ordering: .sequentiallyConsistent) + XCTAssertEqual(w.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + + func test_DoubleWord_exchange_relaxed() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(DoubleWord(high: 100, low: 64), ordering: .relaxed), DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + XCTAssertEqual(v.exchange(DoubleWord(high: 50, low: 32), ordering: .relaxed), DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + XCTAssertEqual(v.exchange(DoubleWord(high: 50, low: 32), ordering: .relaxed), DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + } + func test_DoubleWord_exchange_acquiring() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(DoubleWord(high: 100, low: 64), ordering: .acquiring), DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + XCTAssertEqual(v.exchange(DoubleWord(high: 50, low: 32), ordering: .acquiring), DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + XCTAssertEqual(v.exchange(DoubleWord(high: 50, low: 32), ordering: .acquiring), DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + } + func test_DoubleWord_exchange_releasing() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(DoubleWord(high: 100, low: 64), ordering: .releasing), DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + XCTAssertEqual(v.exchange(DoubleWord(high: 50, low: 32), ordering: .releasing), DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + XCTAssertEqual(v.exchange(DoubleWord(high: 50, low: 32), ordering: .releasing), DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + } + func test_DoubleWord_exchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(DoubleWord(high: 100, low: 64), ordering: .acquiringAndReleasing), DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + XCTAssertEqual(v.exchange(DoubleWord(high: 50, low: 32), ordering: .acquiringAndReleasing), DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + XCTAssertEqual(v.exchange(DoubleWord(high: 50, low: 32), ordering: .acquiringAndReleasing), DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + } + func test_DoubleWord_exchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(DoubleWord(high: 100, low: 64), ordering: .sequentiallyConsistent), DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + XCTAssertEqual(v.exchange(DoubleWord(high: 50, low: 32), ordering: .sequentiallyConsistent), DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + XCTAssertEqual(v.exchange(DoubleWord(high: 50, low: 32), ordering: .sequentiallyConsistent), DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + } + + func test_DoubleWord_compareExchange_relaxed() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_compareExchange_acquiring() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_compareExchange_releasing() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_compareExchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_compareExchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + + func test_DoubleWord_compareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_compareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_compareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_compareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_compareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_compareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_compareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_compareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_compareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_compareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_compareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_compareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_compareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_compareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_compareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_weakCompareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_weakCompareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_weakCompareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_weakCompareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_weakCompareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_weakCompareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_weakCompareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_weakCompareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_weakCompareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_weakCompareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_weakCompareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_weakCompareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_weakCompareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + func test_DoubleWord_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(DoubleWord(high: 100, low: 64)) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 100, low: 64), + desired: DoubleWord(high: 50, low: 32), + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 50, low: 32)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, DoubleWord(high: 50, low: 32)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + + (exchanged, original) = v.compareExchange( + expected: DoubleWord(high: 50, low: 32), + desired: DoubleWord(high: 100, low: 64), + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, DoubleWord(high: 100, low: 64)) + XCTAssertEqual(v.load(ordering: .relaxed), DoubleWord(high: 100, low: 64)) + } + + +// Bool operations + + +// Integer operations + + + func test_Pointer_create_destroy() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + let w = UnsafeAtomic>.create(_foo2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), _foo2) + } + + func test_Pointer_load_relaxed() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + let w = UnsafeAtomic>.create(_foo2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), _foo2) + } + func test_Pointer_load_acquiring() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .acquiring), _foo1) + + let w = UnsafeAtomic>.create(_foo2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .acquiring), _foo2) + } + func test_Pointer_load_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .sequentiallyConsistent), _foo1) + + let w = UnsafeAtomic>.create(_foo2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .sequentiallyConsistent), _foo2) + } + + func test_Pointer_store_relaxed() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + v.store(_foo2, ordering: .relaxed) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + let w = UnsafeAtomic>.create(_foo2) + defer { w.destroy() } + w.store(_foo1, ordering: .relaxed) + XCTAssertEqual(w.load(ordering: .relaxed), _foo1) + } + func test_Pointer_store_releasing() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + v.store(_foo2, ordering: .releasing) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + let w = UnsafeAtomic>.create(_foo2) + defer { w.destroy() } + w.store(_foo1, ordering: .releasing) + XCTAssertEqual(w.load(ordering: .relaxed), _foo1) + } + func test_Pointer_store_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + v.store(_foo2, ordering: .sequentiallyConsistent) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + let w = UnsafeAtomic>.create(_foo2) + defer { w.destroy() } + w.store(_foo1, ordering: .sequentiallyConsistent) + XCTAssertEqual(w.load(ordering: .relaxed), _foo1) + } + + func test_Pointer_exchange_relaxed() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_foo1, ordering: .relaxed), _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + XCTAssertEqual(v.exchange(_foo2, ordering: .relaxed), _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + XCTAssertEqual(v.exchange(_foo2, ordering: .relaxed), _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + } + func test_Pointer_exchange_acquiring() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_foo1, ordering: .acquiring), _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + XCTAssertEqual(v.exchange(_foo2, ordering: .acquiring), _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + XCTAssertEqual(v.exchange(_foo2, ordering: .acquiring), _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + } + func test_Pointer_exchange_releasing() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_foo1, ordering: .releasing), _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + XCTAssertEqual(v.exchange(_foo2, ordering: .releasing), _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + XCTAssertEqual(v.exchange(_foo2, ordering: .releasing), _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + } + func test_Pointer_exchange_acquiringAndReleasing() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_foo1, ordering: .acquiringAndReleasing), _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + XCTAssertEqual(v.exchange(_foo2, ordering: .acquiringAndReleasing), _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + XCTAssertEqual(v.exchange(_foo2, ordering: .acquiringAndReleasing), _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + } + func test_Pointer_exchange_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_foo1, ordering: .sequentiallyConsistent), _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + XCTAssertEqual(v.exchange(_foo2, ordering: .sequentiallyConsistent), _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + XCTAssertEqual(v.exchange(_foo2, ordering: .sequentiallyConsistent), _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + } + + func test_Pointer_compareExchange_relaxed() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_compareExchange_acquiring() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_compareExchange_releasing() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_compareExchange_acquiringAndReleasing() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_compareExchange_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + + func test_Pointer_compareExchange_relaxed_relaxed() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_compareExchange_relaxed_acquiring() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_compareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_compareExchange_acquiring_relaxed() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_compareExchange_acquiring_acquiring() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_compareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_compareExchange_releasing_relaxed() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_compareExchange_releasing_acquiring() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_compareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_compareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_compareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_compareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_compareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_compareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_compareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_weakCompareExchange_relaxed_relaxed() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_weakCompareExchange_relaxed_acquiring() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_weakCompareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_weakCompareExchange_acquiring_relaxed() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_weakCompareExchange_acquiring_acquiring() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_weakCompareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_weakCompareExchange_releasing_relaxed() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_weakCompareExchange_releasing_acquiring() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_weakCompareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_weakCompareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_weakCompareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_weakCompareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_weakCompareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + func test_Pointer_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_foo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo1, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: _foo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo1) + XCTAssertEqual(v.load(ordering: .relaxed), _foo1) + } + + +// Bool operations + + +// Integer operations + + + func test_OptionalPointer_create_destroy() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + let w = UnsafeAtomic?>.create(_foo2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), _foo2) + } + + func test_OptionalPointer_load_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + let w = UnsafeAtomic?>.create(_foo2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), _foo2) + } + func test_OptionalPointer_load_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .acquiring), nil) + + let w = UnsafeAtomic?>.create(_foo2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .acquiring), _foo2) + } + func test_OptionalPointer_load_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .sequentiallyConsistent), nil) + + let w = UnsafeAtomic?>.create(_foo2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .sequentiallyConsistent), _foo2) + } + + func test_OptionalPointer_store_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + v.store(_foo2, ordering: .relaxed) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + let w = UnsafeAtomic?>.create(_foo2) + defer { w.destroy() } + w.store(nil, ordering: .relaxed) + XCTAssertEqual(w.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_store_releasing() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + v.store(_foo2, ordering: .releasing) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + let w = UnsafeAtomic?>.create(_foo2) + defer { w.destroy() } + w.store(nil, ordering: .releasing) + XCTAssertEqual(w.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_store_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + v.store(_foo2, ordering: .sequentiallyConsistent) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + let w = UnsafeAtomic?>.create(_foo2) + defer { w.destroy() } + w.store(nil, ordering: .sequentiallyConsistent) + XCTAssertEqual(w.load(ordering: .relaxed), nil) + } + + func test_OptionalPointer_exchange_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .relaxed), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_foo2, ordering: .relaxed), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + XCTAssertEqual(v.exchange(_foo2, ordering: .relaxed), _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + } + func test_OptionalPointer_exchange_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .acquiring), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_foo2, ordering: .acquiring), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + XCTAssertEqual(v.exchange(_foo2, ordering: .acquiring), _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + } + func test_OptionalPointer_exchange_releasing() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .releasing), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_foo2, ordering: .releasing), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + XCTAssertEqual(v.exchange(_foo2, ordering: .releasing), _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + } + func test_OptionalPointer_exchange_acquiringAndReleasing() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .acquiringAndReleasing), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_foo2, ordering: .acquiringAndReleasing), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + XCTAssertEqual(v.exchange(_foo2, ordering: .acquiringAndReleasing), _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + } + func test_OptionalPointer_exchange_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .sequentiallyConsistent), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_foo2, ordering: .sequentiallyConsistent), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + XCTAssertEqual(v.exchange(_foo2, ordering: .sequentiallyConsistent), _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + } + + func test_OptionalPointer_compareExchange_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_compareExchange_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_compareExchange_releasing() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_compareExchange_acquiringAndReleasing() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_compareExchange_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + + func test_OptionalPointer_compareExchange_relaxed_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_compareExchange_relaxed_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_compareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_compareExchange_acquiring_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_compareExchange_acquiring_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_compareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_compareExchange_releasing_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_compareExchange_releasing_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_compareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_compareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_compareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_compareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_compareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_compareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_compareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_weakCompareExchange_relaxed_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_weakCompareExchange_relaxed_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_weakCompareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_weakCompareExchange_acquiring_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_weakCompareExchange_acquiring_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_weakCompareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_weakCompareExchange_releasing_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_weakCompareExchange_releasing_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_weakCompareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_weakCompareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_weakCompareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_weakCompareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_weakCompareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalPointer_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _foo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), _foo2) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _foo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _foo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + + +// Bool operations + + +// Integer operations + + + func test_MutablePointer_create_destroy() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + let w = UnsafeAtomic>.create(_mfoo2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), _mfoo2) + } + + func test_MutablePointer_load_relaxed() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + let w = UnsafeAtomic>.create(_mfoo2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), _mfoo2) + } + func test_MutablePointer_load_acquiring() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .acquiring), _mfoo1) + + let w = UnsafeAtomic>.create(_mfoo2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .acquiring), _mfoo2) + } + func test_MutablePointer_load_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .sequentiallyConsistent), _mfoo1) + + let w = UnsafeAtomic>.create(_mfoo2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .sequentiallyConsistent), _mfoo2) + } + + func test_MutablePointer_store_relaxed() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + v.store(_mfoo2, ordering: .relaxed) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + let w = UnsafeAtomic>.create(_mfoo2) + defer { w.destroy() } + w.store(_mfoo1, ordering: .relaxed) + XCTAssertEqual(w.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_store_releasing() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + v.store(_mfoo2, ordering: .releasing) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + let w = UnsafeAtomic>.create(_mfoo2) + defer { w.destroy() } + w.store(_mfoo1, ordering: .releasing) + XCTAssertEqual(w.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_store_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + v.store(_mfoo2, ordering: .sequentiallyConsistent) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + let w = UnsafeAtomic>.create(_mfoo2) + defer { w.destroy() } + w.store(_mfoo1, ordering: .sequentiallyConsistent) + XCTAssertEqual(w.load(ordering: .relaxed), _mfoo1) + } + + func test_MutablePointer_exchange_relaxed() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_mfoo1, ordering: .relaxed), _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + XCTAssertEqual(v.exchange(_mfoo2, ordering: .relaxed), _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + XCTAssertEqual(v.exchange(_mfoo2, ordering: .relaxed), _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + } + func test_MutablePointer_exchange_acquiring() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_mfoo1, ordering: .acquiring), _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + XCTAssertEqual(v.exchange(_mfoo2, ordering: .acquiring), _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + XCTAssertEqual(v.exchange(_mfoo2, ordering: .acquiring), _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + } + func test_MutablePointer_exchange_releasing() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_mfoo1, ordering: .releasing), _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + XCTAssertEqual(v.exchange(_mfoo2, ordering: .releasing), _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + XCTAssertEqual(v.exchange(_mfoo2, ordering: .releasing), _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + } + func test_MutablePointer_exchange_acquiringAndReleasing() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_mfoo1, ordering: .acquiringAndReleasing), _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + XCTAssertEqual(v.exchange(_mfoo2, ordering: .acquiringAndReleasing), _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + XCTAssertEqual(v.exchange(_mfoo2, ordering: .acquiringAndReleasing), _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + } + func test_MutablePointer_exchange_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_mfoo1, ordering: .sequentiallyConsistent), _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + XCTAssertEqual(v.exchange(_mfoo2, ordering: .sequentiallyConsistent), _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + XCTAssertEqual(v.exchange(_mfoo2, ordering: .sequentiallyConsistent), _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + } + + func test_MutablePointer_compareExchange_relaxed() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_compareExchange_acquiring() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_compareExchange_releasing() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_compareExchange_acquiringAndReleasing() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_compareExchange_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + + func test_MutablePointer_compareExchange_relaxed_relaxed() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_compareExchange_relaxed_acquiring() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_compareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_compareExchange_acquiring_relaxed() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_compareExchange_acquiring_acquiring() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_compareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_compareExchange_releasing_relaxed() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_compareExchange_releasing_acquiring() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_compareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_compareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_compareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_compareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_compareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_compareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_compareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_weakCompareExchange_relaxed_relaxed() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_weakCompareExchange_relaxed_acquiring() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_weakCompareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_weakCompareExchange_acquiring_relaxed() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_weakCompareExchange_acquiring_acquiring() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_weakCompareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_weakCompareExchange_releasing_relaxed() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_weakCompareExchange_releasing_acquiring() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_weakCompareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_weakCompareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_weakCompareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_weakCompareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_weakCompareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + func test_MutablePointer_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_mfoo1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo1, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: _mfoo1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo1) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo1) + } + + +// Bool operations + + +// Integer operations + + + func test_OptionalMutablePointer_create_destroy() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + let w = UnsafeAtomic?>.create(_mfoo2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), _mfoo2) + } + + func test_OptionalMutablePointer_load_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + let w = UnsafeAtomic?>.create(_mfoo2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), _mfoo2) + } + func test_OptionalMutablePointer_load_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .acquiring), nil) + + let w = UnsafeAtomic?>.create(_mfoo2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .acquiring), _mfoo2) + } + func test_OptionalMutablePointer_load_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .sequentiallyConsistent), nil) + + let w = UnsafeAtomic?>.create(_mfoo2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .sequentiallyConsistent), _mfoo2) + } + + func test_OptionalMutablePointer_store_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + v.store(_mfoo2, ordering: .relaxed) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + let w = UnsafeAtomic?>.create(_mfoo2) + defer { w.destroy() } + w.store(nil, ordering: .relaxed) + XCTAssertEqual(w.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_store_releasing() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + v.store(_mfoo2, ordering: .releasing) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + let w = UnsafeAtomic?>.create(_mfoo2) + defer { w.destroy() } + w.store(nil, ordering: .releasing) + XCTAssertEqual(w.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_store_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + v.store(_mfoo2, ordering: .sequentiallyConsistent) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + let w = UnsafeAtomic?>.create(_mfoo2) + defer { w.destroy() } + w.store(nil, ordering: .sequentiallyConsistent) + XCTAssertEqual(w.load(ordering: .relaxed), nil) + } + + func test_OptionalMutablePointer_exchange_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .relaxed), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_mfoo2, ordering: .relaxed), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + XCTAssertEqual(v.exchange(_mfoo2, ordering: .relaxed), _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + } + func test_OptionalMutablePointer_exchange_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .acquiring), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_mfoo2, ordering: .acquiring), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + XCTAssertEqual(v.exchange(_mfoo2, ordering: .acquiring), _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + } + func test_OptionalMutablePointer_exchange_releasing() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .releasing), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_mfoo2, ordering: .releasing), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + XCTAssertEqual(v.exchange(_mfoo2, ordering: .releasing), _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + } + func test_OptionalMutablePointer_exchange_acquiringAndReleasing() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .acquiringAndReleasing), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_mfoo2, ordering: .acquiringAndReleasing), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + XCTAssertEqual(v.exchange(_mfoo2, ordering: .acquiringAndReleasing), _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + } + func test_OptionalMutablePointer_exchange_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .sequentiallyConsistent), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_mfoo2, ordering: .sequentiallyConsistent), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + XCTAssertEqual(v.exchange(_mfoo2, ordering: .sequentiallyConsistent), _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + } + + func test_OptionalMutablePointer_compareExchange_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_compareExchange_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_compareExchange_releasing() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_compareExchange_acquiringAndReleasing() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_compareExchange_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + + func test_OptionalMutablePointer_compareExchange_relaxed_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_compareExchange_relaxed_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_compareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_compareExchange_acquiring_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_compareExchange_acquiring_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_compareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_compareExchange_releasing_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_compareExchange_releasing_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_compareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_compareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_compareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_compareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_compareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_compareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_compareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_weakCompareExchange_relaxed_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_weakCompareExchange_relaxed_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_weakCompareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_weakCompareExchange_acquiring_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_weakCompareExchange_acquiring_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_weakCompareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_weakCompareExchange_releasing_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_weakCompareExchange_releasing_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_weakCompareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_weakCompareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_weakCompareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_weakCompareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_weakCompareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalMutablePointer_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _mfoo2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), _mfoo2) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _mfoo2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _mfoo2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + + +// Bool operations + + +// Integer operations + + + func test_RawPointer_create_destroy() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + let w = UnsafeAtomic.create(_raw2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), _raw2) + } + + func test_RawPointer_load_relaxed() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + let w = UnsafeAtomic.create(_raw2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), _raw2) + } + func test_RawPointer_load_acquiring() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .acquiring), _raw1) + + let w = UnsafeAtomic.create(_raw2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .acquiring), _raw2) + } + func test_RawPointer_load_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .sequentiallyConsistent), _raw1) + + let w = UnsafeAtomic.create(_raw2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .sequentiallyConsistent), _raw2) + } + + func test_RawPointer_store_relaxed() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + v.store(_raw2, ordering: .relaxed) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + let w = UnsafeAtomic.create(_raw2) + defer { w.destroy() } + w.store(_raw1, ordering: .relaxed) + XCTAssertEqual(w.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_store_releasing() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + v.store(_raw2, ordering: .releasing) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + let w = UnsafeAtomic.create(_raw2) + defer { w.destroy() } + w.store(_raw1, ordering: .releasing) + XCTAssertEqual(w.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_store_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + v.store(_raw2, ordering: .sequentiallyConsistent) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + let w = UnsafeAtomic.create(_raw2) + defer { w.destroy() } + w.store(_raw1, ordering: .sequentiallyConsistent) + XCTAssertEqual(w.load(ordering: .relaxed), _raw1) + } + + func test_RawPointer_exchange_relaxed() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_raw1, ordering: .relaxed), _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + XCTAssertEqual(v.exchange(_raw2, ordering: .relaxed), _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + XCTAssertEqual(v.exchange(_raw2, ordering: .relaxed), _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + } + func test_RawPointer_exchange_acquiring() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_raw1, ordering: .acquiring), _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + XCTAssertEqual(v.exchange(_raw2, ordering: .acquiring), _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + XCTAssertEqual(v.exchange(_raw2, ordering: .acquiring), _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + } + func test_RawPointer_exchange_releasing() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_raw1, ordering: .releasing), _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + XCTAssertEqual(v.exchange(_raw2, ordering: .releasing), _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + XCTAssertEqual(v.exchange(_raw2, ordering: .releasing), _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + } + func test_RawPointer_exchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_raw1, ordering: .acquiringAndReleasing), _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + XCTAssertEqual(v.exchange(_raw2, ordering: .acquiringAndReleasing), _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + XCTAssertEqual(v.exchange(_raw2, ordering: .acquiringAndReleasing), _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + } + func test_RawPointer_exchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_raw1, ordering: .sequentiallyConsistent), _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + XCTAssertEqual(v.exchange(_raw2, ordering: .sequentiallyConsistent), _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + XCTAssertEqual(v.exchange(_raw2, ordering: .sequentiallyConsistent), _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + } + + func test_RawPointer_compareExchange_relaxed() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_compareExchange_acquiring() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_compareExchange_releasing() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_compareExchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_compareExchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + + func test_RawPointer_compareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_compareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_compareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_compareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_compareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_compareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_compareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_compareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_compareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_compareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_compareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_compareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_compareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_compareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_compareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_weakCompareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_weakCompareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_weakCompareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_weakCompareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_weakCompareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_weakCompareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_weakCompareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_weakCompareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_weakCompareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_weakCompareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_weakCompareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_weakCompareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_weakCompareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + func test_RawPointer_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_raw1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw1, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: _raw1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw1) + XCTAssertEqual(v.load(ordering: .relaxed), _raw1) + } + + +// Bool operations + + +// Integer operations + + + func test_OptionalRawPointer_create_destroy() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + let w = UnsafeAtomic.create(_raw2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), _raw2) + } + + func test_OptionalRawPointer_load_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + let w = UnsafeAtomic.create(_raw2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), _raw2) + } + func test_OptionalRawPointer_load_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .acquiring), nil) + + let w = UnsafeAtomic.create(_raw2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .acquiring), _raw2) + } + func test_OptionalRawPointer_load_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .sequentiallyConsistent), nil) + + let w = UnsafeAtomic.create(_raw2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .sequentiallyConsistent), _raw2) + } + + func test_OptionalRawPointer_store_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + v.store(_raw2, ordering: .relaxed) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + let w = UnsafeAtomic.create(_raw2) + defer { w.destroy() } + w.store(nil, ordering: .relaxed) + XCTAssertEqual(w.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_store_releasing() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + v.store(_raw2, ordering: .releasing) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + let w = UnsafeAtomic.create(_raw2) + defer { w.destroy() } + w.store(nil, ordering: .releasing) + XCTAssertEqual(w.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_store_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + v.store(_raw2, ordering: .sequentiallyConsistent) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + let w = UnsafeAtomic.create(_raw2) + defer { w.destroy() } + w.store(nil, ordering: .sequentiallyConsistent) + XCTAssertEqual(w.load(ordering: .relaxed), nil) + } + + func test_OptionalRawPointer_exchange_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .relaxed), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_raw2, ordering: .relaxed), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + XCTAssertEqual(v.exchange(_raw2, ordering: .relaxed), _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + } + func test_OptionalRawPointer_exchange_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .acquiring), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_raw2, ordering: .acquiring), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + XCTAssertEqual(v.exchange(_raw2, ordering: .acquiring), _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + } + func test_OptionalRawPointer_exchange_releasing() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .releasing), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_raw2, ordering: .releasing), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + XCTAssertEqual(v.exchange(_raw2, ordering: .releasing), _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + } + func test_OptionalRawPointer_exchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .acquiringAndReleasing), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_raw2, ordering: .acquiringAndReleasing), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + XCTAssertEqual(v.exchange(_raw2, ordering: .acquiringAndReleasing), _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + } + func test_OptionalRawPointer_exchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .sequentiallyConsistent), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_raw2, ordering: .sequentiallyConsistent), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + XCTAssertEqual(v.exchange(_raw2, ordering: .sequentiallyConsistent), _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + } + + func test_OptionalRawPointer_compareExchange_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_compareExchange_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_compareExchange_releasing() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_compareExchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_compareExchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + + func test_OptionalRawPointer_compareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_compareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_compareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_compareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_compareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_compareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_compareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_compareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_compareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_compareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_compareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_compareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_compareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_compareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_compareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_weakCompareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_weakCompareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_weakCompareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_weakCompareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_weakCompareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_weakCompareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_weakCompareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_weakCompareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_weakCompareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_weakCompareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_weakCompareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_weakCompareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_weakCompareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalRawPointer_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _raw2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), _raw2) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _raw2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _raw2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + + +// Bool operations + + +// Integer operations + + + func test_Unmanaged_create_destroy() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + let w = UnsafeAtomic>.create(_bar2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), _bar2) + } + + func test_Unmanaged_load_relaxed() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + let w = UnsafeAtomic>.create(_bar2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), _bar2) + } + func test_Unmanaged_load_acquiring() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .acquiring), _bar1) + + let w = UnsafeAtomic>.create(_bar2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .acquiring), _bar2) + } + func test_Unmanaged_load_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .sequentiallyConsistent), _bar1) + + let w = UnsafeAtomic>.create(_bar2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .sequentiallyConsistent), _bar2) + } + + func test_Unmanaged_store_relaxed() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + v.store(_bar2, ordering: .relaxed) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + let w = UnsafeAtomic>.create(_bar2) + defer { w.destroy() } + w.store(_bar1, ordering: .relaxed) + XCTAssertEqual(w.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_store_releasing() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + v.store(_bar2, ordering: .releasing) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + let w = UnsafeAtomic>.create(_bar2) + defer { w.destroy() } + w.store(_bar1, ordering: .releasing) + XCTAssertEqual(w.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_store_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + v.store(_bar2, ordering: .sequentiallyConsistent) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + let w = UnsafeAtomic>.create(_bar2) + defer { w.destroy() } + w.store(_bar1, ordering: .sequentiallyConsistent) + XCTAssertEqual(w.load(ordering: .relaxed), _bar1) + } + + func test_Unmanaged_exchange_relaxed() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_bar1, ordering: .relaxed), _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + XCTAssertEqual(v.exchange(_bar2, ordering: .relaxed), _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + XCTAssertEqual(v.exchange(_bar2, ordering: .relaxed), _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + } + func test_Unmanaged_exchange_acquiring() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_bar1, ordering: .acquiring), _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + XCTAssertEqual(v.exchange(_bar2, ordering: .acquiring), _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + XCTAssertEqual(v.exchange(_bar2, ordering: .acquiring), _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + } + func test_Unmanaged_exchange_releasing() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_bar1, ordering: .releasing), _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + XCTAssertEqual(v.exchange(_bar2, ordering: .releasing), _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + XCTAssertEqual(v.exchange(_bar2, ordering: .releasing), _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + } + func test_Unmanaged_exchange_acquiringAndReleasing() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_bar1, ordering: .acquiringAndReleasing), _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + XCTAssertEqual(v.exchange(_bar2, ordering: .acquiringAndReleasing), _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + XCTAssertEqual(v.exchange(_bar2, ordering: .acquiringAndReleasing), _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + } + func test_Unmanaged_exchange_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_bar1, ordering: .sequentiallyConsistent), _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + XCTAssertEqual(v.exchange(_bar2, ordering: .sequentiallyConsistent), _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + XCTAssertEqual(v.exchange(_bar2, ordering: .sequentiallyConsistent), _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + } + + func test_Unmanaged_compareExchange_relaxed() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_compareExchange_acquiring() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_compareExchange_releasing() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_compareExchange_acquiringAndReleasing() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_compareExchange_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + + func test_Unmanaged_compareExchange_relaxed_relaxed() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_compareExchange_relaxed_acquiring() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_compareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_compareExchange_acquiring_relaxed() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_compareExchange_acquiring_acquiring() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_compareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_compareExchange_releasing_relaxed() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_compareExchange_releasing_acquiring() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_compareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_compareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_compareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_compareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_compareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_compareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_compareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_weakCompareExchange_relaxed_relaxed() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_weakCompareExchange_relaxed_acquiring() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_weakCompareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_weakCompareExchange_acquiring_relaxed() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_weakCompareExchange_acquiring_acquiring() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_weakCompareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_weakCompareExchange_releasing_relaxed() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_weakCompareExchange_releasing_acquiring() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_weakCompareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_weakCompareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_weakCompareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_weakCompareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_weakCompareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + func test_Unmanaged_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic>.create(_bar1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar1, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: _bar1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar1) + XCTAssertEqual(v.load(ordering: .relaxed), _bar1) + } + + +// Bool operations + + +// Integer operations + + + func test_OptionalUnmanaged_create_destroy() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + let w = UnsafeAtomic?>.create(_bar2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), _bar2) + } + + func test_OptionalUnmanaged_load_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + let w = UnsafeAtomic?>.create(_bar2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), _bar2) + } + func test_OptionalUnmanaged_load_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .acquiring), nil) + + let w = UnsafeAtomic?>.create(_bar2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .acquiring), _bar2) + } + func test_OptionalUnmanaged_load_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .sequentiallyConsistent), nil) + + let w = UnsafeAtomic?>.create(_bar2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .sequentiallyConsistent), _bar2) + } + + func test_OptionalUnmanaged_store_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + v.store(_bar2, ordering: .relaxed) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + let w = UnsafeAtomic?>.create(_bar2) + defer { w.destroy() } + w.store(nil, ordering: .relaxed) + XCTAssertEqual(w.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_store_releasing() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + v.store(_bar2, ordering: .releasing) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + let w = UnsafeAtomic?>.create(_bar2) + defer { w.destroy() } + w.store(nil, ordering: .releasing) + XCTAssertEqual(w.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_store_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + v.store(_bar2, ordering: .sequentiallyConsistent) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + let w = UnsafeAtomic?>.create(_bar2) + defer { w.destroy() } + w.store(nil, ordering: .sequentiallyConsistent) + XCTAssertEqual(w.load(ordering: .relaxed), nil) + } + + func test_OptionalUnmanaged_exchange_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .relaxed), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_bar2, ordering: .relaxed), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + XCTAssertEqual(v.exchange(_bar2, ordering: .relaxed), _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + } + func test_OptionalUnmanaged_exchange_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .acquiring), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_bar2, ordering: .acquiring), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + XCTAssertEqual(v.exchange(_bar2, ordering: .acquiring), _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + } + func test_OptionalUnmanaged_exchange_releasing() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .releasing), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_bar2, ordering: .releasing), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + XCTAssertEqual(v.exchange(_bar2, ordering: .releasing), _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + } + func test_OptionalUnmanaged_exchange_acquiringAndReleasing() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .acquiringAndReleasing), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_bar2, ordering: .acquiringAndReleasing), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + XCTAssertEqual(v.exchange(_bar2, ordering: .acquiringAndReleasing), _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + } + func test_OptionalUnmanaged_exchange_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .sequentiallyConsistent), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_bar2, ordering: .sequentiallyConsistent), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + XCTAssertEqual(v.exchange(_bar2, ordering: .sequentiallyConsistent), _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + } + + func test_OptionalUnmanaged_compareExchange_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_compareExchange_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_compareExchange_releasing() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_compareExchange_acquiringAndReleasing() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_compareExchange_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + + func test_OptionalUnmanaged_compareExchange_relaxed_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_compareExchange_relaxed_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_compareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_compareExchange_acquiring_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_compareExchange_acquiring_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_compareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_compareExchange_releasing_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_compareExchange_releasing_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_compareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_compareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_compareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_compareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_compareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_compareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_compareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_weakCompareExchange_relaxed_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_weakCompareExchange_relaxed_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_weakCompareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_weakCompareExchange_acquiring_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_weakCompareExchange_acquiring_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_weakCompareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_weakCompareExchange_releasing_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_weakCompareExchange_releasing_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_weakCompareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_weakCompareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_weakCompareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_weakCompareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_weakCompareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalUnmanaged_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic?>.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _bar2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), _bar2) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _bar2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _bar2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + + +// Bool operations + + +// Integer operations + + + func test_Reference_create_destroy() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + let w = UnsafeAtomic.create(_baz2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), _baz2) + } + + func test_Reference_load_relaxed() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + let w = UnsafeAtomic.create(_baz2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), _baz2) + } + func test_Reference_load_acquiring() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .acquiring), _baz1) + + let w = UnsafeAtomic.create(_baz2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .acquiring), _baz2) + } + func test_Reference_load_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .sequentiallyConsistent), _baz1) + + let w = UnsafeAtomic.create(_baz2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .sequentiallyConsistent), _baz2) + } + + func test_Reference_store_relaxed() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + v.store(_baz2, ordering: .relaxed) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + let w = UnsafeAtomic.create(_baz2) + defer { w.destroy() } + w.store(_baz1, ordering: .relaxed) + XCTAssertEqual(w.load(ordering: .relaxed), _baz1) + } + func test_Reference_store_releasing() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + v.store(_baz2, ordering: .releasing) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + let w = UnsafeAtomic.create(_baz2) + defer { w.destroy() } + w.store(_baz1, ordering: .releasing) + XCTAssertEqual(w.load(ordering: .relaxed), _baz1) + } + func test_Reference_store_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + v.store(_baz2, ordering: .sequentiallyConsistent) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + let w = UnsafeAtomic.create(_baz2) + defer { w.destroy() } + w.store(_baz1, ordering: .sequentiallyConsistent) + XCTAssertEqual(w.load(ordering: .relaxed), _baz1) + } + + func test_Reference_exchange_relaxed() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_baz1, ordering: .relaxed), _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + XCTAssertEqual(v.exchange(_baz2, ordering: .relaxed), _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + XCTAssertEqual(v.exchange(_baz2, ordering: .relaxed), _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + } + func test_Reference_exchange_acquiring() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_baz1, ordering: .acquiring), _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + XCTAssertEqual(v.exchange(_baz2, ordering: .acquiring), _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + XCTAssertEqual(v.exchange(_baz2, ordering: .acquiring), _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + } + func test_Reference_exchange_releasing() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_baz1, ordering: .releasing), _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + XCTAssertEqual(v.exchange(_baz2, ordering: .releasing), _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + XCTAssertEqual(v.exchange(_baz2, ordering: .releasing), _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + } + func test_Reference_exchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_baz1, ordering: .acquiringAndReleasing), _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + XCTAssertEqual(v.exchange(_baz2, ordering: .acquiringAndReleasing), _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + XCTAssertEqual(v.exchange(_baz2, ordering: .acquiringAndReleasing), _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + } + func test_Reference_exchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(_baz1, ordering: .sequentiallyConsistent), _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + XCTAssertEqual(v.exchange(_baz2, ordering: .sequentiallyConsistent), _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + XCTAssertEqual(v.exchange(_baz2, ordering: .sequentiallyConsistent), _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + } + + func test_Reference_compareExchange_relaxed() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_compareExchange_acquiring() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_compareExchange_releasing() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_compareExchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_compareExchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + + func test_Reference_compareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_compareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_compareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_compareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_compareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_compareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_compareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_compareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_compareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_compareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_compareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_compareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_compareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_compareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_compareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_weakCompareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_weakCompareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_weakCompareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_weakCompareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_weakCompareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_weakCompareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_weakCompareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_weakCompareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_weakCompareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_weakCompareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_weakCompareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_weakCompareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_weakCompareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + func test_Reference_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(_baz1) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz1, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: _baz1, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz1) + XCTAssertEqual(v.load(ordering: .relaxed), _baz1) + } + + +// Bool operations + + +// Integer operations + + + func test_OptionalReference_create_destroy() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + let w = UnsafeAtomic.create(_baz2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), _baz2) + } + + func test_OptionalReference_load_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + let w = UnsafeAtomic.create(_baz2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), _baz2) + } + func test_OptionalReference_load_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .acquiring), nil) + + let w = UnsafeAtomic.create(_baz2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .acquiring), _baz2) + } + func test_OptionalReference_load_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .sequentiallyConsistent), nil) + + let w = UnsafeAtomic.create(_baz2) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .sequentiallyConsistent), _baz2) + } + + func test_OptionalReference_store_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + v.store(_baz2, ordering: .relaxed) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + let w = UnsafeAtomic.create(_baz2) + defer { w.destroy() } + w.store(nil, ordering: .relaxed) + XCTAssertEqual(w.load(ordering: .relaxed), nil) + } + func test_OptionalReference_store_releasing() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + v.store(_baz2, ordering: .releasing) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + let w = UnsafeAtomic.create(_baz2) + defer { w.destroy() } + w.store(nil, ordering: .releasing) + XCTAssertEqual(w.load(ordering: .relaxed), nil) + } + func test_OptionalReference_store_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + v.store(_baz2, ordering: .sequentiallyConsistent) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + let w = UnsafeAtomic.create(_baz2) + defer { w.destroy() } + w.store(nil, ordering: .sequentiallyConsistent) + XCTAssertEqual(w.load(ordering: .relaxed), nil) + } + + func test_OptionalReference_exchange_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .relaxed), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_baz2, ordering: .relaxed), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + XCTAssertEqual(v.exchange(_baz2, ordering: .relaxed), _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + } + func test_OptionalReference_exchange_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .acquiring), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_baz2, ordering: .acquiring), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + XCTAssertEqual(v.exchange(_baz2, ordering: .acquiring), _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + } + func test_OptionalReference_exchange_releasing() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .releasing), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_baz2, ordering: .releasing), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + XCTAssertEqual(v.exchange(_baz2, ordering: .releasing), _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + } + func test_OptionalReference_exchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .acquiringAndReleasing), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_baz2, ordering: .acquiringAndReleasing), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + XCTAssertEqual(v.exchange(_baz2, ordering: .acquiringAndReleasing), _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + } + func test_OptionalReference_exchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(nil, ordering: .sequentiallyConsistent), nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + XCTAssertEqual(v.exchange(_baz2, ordering: .sequentiallyConsistent), nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + XCTAssertEqual(v.exchange(_baz2, ordering: .sequentiallyConsistent), _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + } + + func test_OptionalReference_compareExchange_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_compareExchange_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_compareExchange_releasing() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_compareExchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_compareExchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + + func test_OptionalReference_compareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_compareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_compareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_compareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_compareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_compareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_compareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_compareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_compareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_compareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_compareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_compareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_compareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_compareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_compareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_weakCompareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_weakCompareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_weakCompareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_weakCompareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_weakCompareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_weakCompareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_weakCompareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_weakCompareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_weakCompareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_weakCompareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_weakCompareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_weakCompareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_weakCompareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + func test_OptionalReference_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(nil) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: nil, + desired: _baz2, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), _baz2) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, _baz2) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + + (exchanged, original) = v.compareExchange( + expected: _baz2, + desired: nil, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, nil) + XCTAssertEqual(v.load(ordering: .relaxed), nil) + } + + +// Bool operations + + +// Integer operations + + + func test_RawRepresentable_create_destroy() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + let w = UnsafeAtomic.create(Fred.two) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), Fred.two) + } + + func test_RawRepresentable_load_relaxed() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + let w = UnsafeAtomic.create(Fred.two) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .relaxed), Fred.two) + } + func test_RawRepresentable_load_acquiring() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .acquiring), Fred.one) + + let w = UnsafeAtomic.create(Fred.two) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .acquiring), Fred.two) + } + func test_RawRepresentable_load_sequentiallyConsistent() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + XCTAssertEqual(v.load(ordering: .sequentiallyConsistent), Fred.one) + + let w = UnsafeAtomic.create(Fred.two) + defer { w.destroy() } + XCTAssertEqual(w.load(ordering: .sequentiallyConsistent), Fred.two) + } + + func test_RawRepresentable_store_relaxed() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + v.store(Fred.two, ordering: .relaxed) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + let w = UnsafeAtomic.create(Fred.two) + defer { w.destroy() } + w.store(Fred.one, ordering: .relaxed) + XCTAssertEqual(w.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_store_releasing() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + v.store(Fred.two, ordering: .releasing) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + let w = UnsafeAtomic.create(Fred.two) + defer { w.destroy() } + w.store(Fred.one, ordering: .releasing) + XCTAssertEqual(w.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_store_sequentiallyConsistent() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + v.store(Fred.two, ordering: .sequentiallyConsistent) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + let w = UnsafeAtomic.create(Fred.two) + defer { w.destroy() } + w.store(Fred.one, ordering: .sequentiallyConsistent) + XCTAssertEqual(w.load(ordering: .relaxed), Fred.one) + } + + func test_RawRepresentable_exchange_relaxed() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(Fred.one, ordering: .relaxed), Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + XCTAssertEqual(v.exchange(Fred.two, ordering: .relaxed), Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + XCTAssertEqual(v.exchange(Fred.two, ordering: .relaxed), Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + } + func test_RawRepresentable_exchange_acquiring() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(Fred.one, ordering: .acquiring), Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + XCTAssertEqual(v.exchange(Fred.two, ordering: .acquiring), Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + XCTAssertEqual(v.exchange(Fred.two, ordering: .acquiring), Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + } + func test_RawRepresentable_exchange_releasing() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(Fred.one, ordering: .releasing), Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + XCTAssertEqual(v.exchange(Fred.two, ordering: .releasing), Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + XCTAssertEqual(v.exchange(Fred.two, ordering: .releasing), Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + } + func test_RawRepresentable_exchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(Fred.one, ordering: .acquiringAndReleasing), Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + XCTAssertEqual(v.exchange(Fred.two, ordering: .acquiringAndReleasing), Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + XCTAssertEqual(v.exchange(Fred.two, ordering: .acquiringAndReleasing), Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + } + func test_RawRepresentable_exchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + XCTAssertEqual(v.exchange(Fred.one, ordering: .sequentiallyConsistent), Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + XCTAssertEqual(v.exchange(Fred.two, ordering: .sequentiallyConsistent), Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + XCTAssertEqual(v.exchange(Fred.two, ordering: .sequentiallyConsistent), Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + } + + func test_RawRepresentable_compareExchange_relaxed() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + ordering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + ordering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_compareExchange_acquiring() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + ordering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + ordering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_compareExchange_releasing() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + ordering: .releasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + ordering: .releasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_compareExchange_acquiringAndReleasing() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + ordering: .acquiringAndReleasing) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + ordering: .acquiringAndReleasing) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_compareExchange_sequentiallyConsistent() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + ordering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + ordering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + + func test_RawRepresentable_compareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_compareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_compareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_compareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_compareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_compareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_compareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_compareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_compareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_compareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_compareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_compareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_compareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_compareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_compareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_weakCompareExchange_relaxed_relaxed() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .relaxed, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_weakCompareExchange_relaxed_acquiring() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .relaxed, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_weakCompareExchange_relaxed_sequentiallyConsistent() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_weakCompareExchange_acquiring_relaxed() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiring, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_weakCompareExchange_acquiring_acquiring() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiring, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_weakCompareExchange_acquiring_sequentiallyConsistent() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiring, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_weakCompareExchange_releasing_relaxed() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .releasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_weakCompareExchange_releasing_acquiring() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .releasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_weakCompareExchange_releasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .releasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_weakCompareExchange_acquiringAndReleasing_relaxed() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiringAndReleasing, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_weakCompareExchange_acquiringAndReleasing_acquiring() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiringAndReleasing, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_weakCompareExchange_acquiringAndReleasing_sequentiallyConsistent() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .acquiringAndReleasing, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_weakCompareExchange_sequentiallyConsistent_relaxed() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .sequentiallyConsistent, + failureOrdering: .relaxed) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_weakCompareExchange_sequentiallyConsistent_acquiring() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + func test_RawRepresentable_weakCompareExchange_sequentiallyConsistent_sequentiallyConsistent() { + let v = UnsafeAtomic.create(Fred.one) + defer { v.destroy() } + + var (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.one, + desired: Fred.two, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.two) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertTrue(exchanged) + XCTAssertEqual(original, Fred.two) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + + (exchanged, original) = v.compareExchange( + expected: Fred.two, + desired: Fred.one, + successOrdering: .sequentiallyConsistent, + failureOrdering: .sequentiallyConsistent) + XCTAssertFalse(exchanged) + XCTAssertEqual(original, Fred.one) + XCTAssertEqual(v.load(ordering: .relaxed), Fred.one) + } + + +// Bool operations + + +// Integer operations + + +} diff --git a/Tests/LinuxMain.swift b/Tests/LinuxMain.swift new file mode 100644 index 0000000..57979de --- /dev/null +++ b/Tests/LinuxMain.swift @@ -0,0 +1,8 @@ +import XCTest + +import AtomicsTests + +var tests = [XCTestCaseEntry]() +tests += AtomicsTests.__allTests() + +XCTMain(tests) diff --git a/Tests/lit/AtomicsFolding.swift.gyb b/Tests/lit/AtomicsFolding.swift.gyb new file mode 100644 index 0000000..3a5a480 --- /dev/null +++ b/Tests/lit/AtomicsFolding.swift.gyb @@ -0,0 +1,550 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// +// RUN: %empty-directory(%t) +// RUN: %gyb %s > %t/AtomicsFolding.swift +// +// RUN: %target-swift-frontend -parse-as-library -emit-sil -Onone -module-name AtomicsFolding %t/AtomicsFolding.swift > %t/AtomicsFolding-Onone.sil +// RUN: %FileCheck --check-prefixes=SECTIONING,CHECK --input-file=%t/AtomicsFolding-Onone.sil %t/AtomicsFolding.swift +// RUN: %FileCheck --check-prefixes=SECTIONING,EXCLUSIONS --input-file=%t/AtomicsFolding-Onone.sil %t/AtomicsFolding.swift +// +// RUN: %target-swift-frontend -parse-as-library -emit-sil -O -module-name AtomicsFolding %t/AtomicsFolding.swift > %t/AtomicsFolding-O.sil +// RUN: %FileCheck --check-prefixes=SECTIONING,CHECK --input-file=%t/AtomicsFolding-O.sil %t/AtomicsFolding.swift +// RUN: %FileCheck --check-prefixes=SECTIONING,EXCLUSIONS --input-file=%t/AtomicsFolding-O.sil %t/AtomicsFolding.swift +// +// RUN: %target-swift-frontend -parse-as-library -emit-sil -Osize -module-name AtomicsFolding %t/AtomicsFolding.swift > %t/AtomicsFolding-Osize.sil +// RUN: %FileCheck --check-prefixes=SECTIONING,CHECK --input-file=%t/AtomicsFolding-Osize.sil %t/AtomicsFolding.swift +// RUN: %FileCheck --check-prefixes=SECTIONING,EXCLUSIONS --input-file=%t/AtomicsFolding-Osize.sil %t/AtomicsFolding.swift + +// Tests that atomic operations get compiled to the expected builtins, and only +// the expected builtins. (I.e., that the switch statements over the orderings +// get constant folded away.) + +%{ + from gyb_utils import autogenerated_warning + + integer_types = [ + # Label Type Builtin + ("Int", "Int", "Word"), + ("Int64", "Int64", "Int64"), + ("Int32", "Int32", "Int32"), + ("Int16", "Int16", "Int16"), + ("Int8", "Int8", "Int8"), + ("UInt", "UInt", "Word"), + ("UInt64", "UInt64", "Int64"), + ("UInt32", "UInt32", "Int32"), + ("UInt16", "UInt16", "Int16"), + ("UInt8", "UInt8", "Int8"), + ] + + pointer_types = [ + # Label Type Builtin + ("UnsafeRawPointer", "UnsafeRawPointer", "Word"), + ("UnsafeMutableRawPointer", "UnsafeMutableRawPointer", "Word"), + ("UnsafePointer", "UnsafePointer", "Word"), + ("UnsafeMutablePointer", "UnsafeMutablePointer", "Word"), + ("Unmanaged", "Unmanaged", "Word"), + ("OptionalUnsafeRawPointer", "Optional", "Word"), + ("OptionalUnsafeMutableRawPointer", "Optional", "Word"), + ("OptionalUnsafePointer", "Optional>", "Word"), + ("OptionalUnsafeMutablePointer", "Optional>", "Word"), + ("OptionalUnmanaged", "Optional>", "Word"), + ] + + all_types = integer_types + pointer_types + + integer_operations = [ + # API Name LLVM Op Arg Label + ('loadThenWrappingIncrement', 'add', "by"), + ('loadThenWrappingDecrement', 'sub', "by"), + ('loadThenBitwiseAnd', 'and', "with"), + ('loadThenBitwiseOr', 'or', "with"), + ('loadThenBitwiseXor', 'xor', "with"), + ('wrappingIncrementThenLoad', 'add', "by"), + ('wrappingDecrementThenLoad', 'sub', "by"), + ('bitwiseAndThenLoad', 'and', "with"), + ('bitwiseOrThenLoad', 'or', "with"), + ('bitwiseXorThenLoad', 'xor', "with"), + ] +}% +${autogenerated_warning()} + +import Atomics + +public struct Foo {} +public class Bar {} + +// ----------------------------------------------------------------------------- + +public struct AtomicFoldingTests { + % for (label, type, builtin) in all_types: + // SECTIONING-LABEL: // AtomicFoldingTests.load_${label}_relaxed(_:) + public func load_${label}_relaxed( + _ value: UnsafeAtomic<${type}> + ) -> ${type} { + // CHECK: builtin "atomicload_monotonic_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_${builtin}" + return value.load(ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_${label}_acquiring(_:) + public func load_${label}_acquiring( + _ value: UnsafeAtomic<${type}> + ) -> ${type} { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_${builtin}" + // CHECK: builtin "atomicload_acquire_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_${builtin}" + return value.load(ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_${label}_sequential(_:) + public func load_${label}_sequential( + _ value: UnsafeAtomic<${type}> + ) -> ${type} { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_${builtin}" + // CHECK: builtin "atomicload_seqcst_${builtin}" + return value.load(ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + %end + // --------------------------------------------------------------------------- + + % for (label, type, builtin) in all_types: + // SECTIONING-LABEL: // AtomicFoldingTests.store_${label}_relaxed(_:_:) + public func store_${label}_relaxed( + _ value: UnsafeAtomic<${type}>, + _ desired: ${type} + ) { + // CHECK: builtin "atomicstore_monotonic_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicstore_release_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_${builtin}" + value.store(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_${label}_releasing(_:_:) + public func store_${label}_releasing( + _ value: UnsafeAtomic<${type}>, + _ desired: ${type} + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_${builtin}" + // CHECK: builtin "atomicstore_release_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_${builtin}" + value.store(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_${label}_sequential(_:_:) + public func store_${label}_sequential( + _ value: UnsafeAtomic<${type}>, + _ desired: ${type} + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicstore_release_${builtin}" + // CHECK: builtin "atomicstore_seqcst_${builtin}" + value.store(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + %end + // --------------------------------------------------------------------------- + + % for (label, type, builtin) in all_types: + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_${label}_relaxed(_:_:) + public func exchange_${label}_relaxed( + _ value: UnsafeAtomic<${type}>, + _ desired: ${type} + ) -> ${type} { + // CHECK: builtin "atomicrmw_xchg_monotonic_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_${builtin}" + return value.exchange(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_${label}_acquiring(_:_:) + public func exchange_${label}_acquiring( + _ value: UnsafeAtomic<${type}>, + _ desired: ${type} + ) -> ${type} { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_${builtin}" + // CHECK: builtin "atomicrmw_xchg_acquire_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_${builtin}" + return value.exchange(desired, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_${label}_releasing(_:_:) + public func exchange_${label}_releasing( + _ value: UnsafeAtomic<${type}>, + _ desired: ${type} + ) -> ${type} { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_${builtin}" + // CHECK: builtin "atomicrmw_xchg_release_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_${builtin}" + return value.exchange(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_${label}_acquiringAndReleasing(_:_:) + public func exchange_${label}_acquiringAndReleasing( + _ value: UnsafeAtomic<${type}>, + _ desired: ${type} + ) -> ${type} { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_${builtin}" + // CHECK: builtin "atomicrmw_xchg_acqrel_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_${builtin}" + return value.exchange(desired, ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_${label}_sequential(_:_:) + public func exchange_${label}_sequential( + _ value: UnsafeAtomic<${type}>, + _ desired: ${type} + ) -> ${type} { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_${builtin}" + // CHECK: builtin "atomicrmw_xchg_seqcst_${builtin}" + return value.exchange(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + %end + // --------------------------------------------------------------------------- + + % for (label, type, builtin) in all_types: + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_${label}_relaxed(_:_:_:) + public func compareExchange_${label}_relaxed( + _ value: UnsafeAtomic<${type}>, + _ expected: ${type}, + _ desired: ${type} + ) -> (exchanged: Bool, original: ${type}) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_${builtin}" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_${label}_acquiring(_:_:_:) + public func compareExchange_${label}_acquiring( + _ value: UnsafeAtomic<${type}>, + _ expected: ${type}, + _ desired: ${type} + ) -> (exchanged: Bool, original: ${type}) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_${builtin}" + // CHECK: builtin "cmpxchg_acquire_acquire_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_${builtin}" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_${label}_releasing(_:_:_:) + public func compareExchange_${label}_releasing( + _ value: UnsafeAtomic<${type}>, + _ expected: ${type}, + _ desired: ${type} + ) -> (exchanged: Bool, original: ${type}) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_${builtin}" + // CHECK: builtin "cmpxchg_release_monotonic_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_${builtin}" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_${label}_acquiringAndReleasing(_:_:_:) + public func compareExchange_${label}_acquiringAndReleasing( + _ value: UnsafeAtomic<${type}>, + _ expected: ${type}, + _ desired: ${type} + ) -> (exchanged: Bool, original: ${type}) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_${builtin}" + // CHECK: builtin "cmpxchg_acqrel_acquire_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_${builtin}" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_${label}_sequential(_:_:_:) + public func compareExchange_${label}_sequential( + _ value: UnsafeAtomic<${type}>, + _ expected: ${type}, + _ desired: ${type} + ) -> (exchanged: Bool, original: ${type}) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_${builtin}" + // CHECK: builtin "cmpxchg_seqcst_seqcst_${builtin}" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + % end + + % for (operation, modifier) in [("compareExchange", ""), ("weakCompareExchange", "_weak")]: + // --------------------------------------------------------------------------- + // FIXME: There are 15 valid combinations of success/failure orderings; + // here we're only testing 6 of them. + + % for (label, type, builtin) in all_types: + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_${label}_relaxed_relaxed${modifier}(_:_:_:) + public func compareExchange2_${label}_relaxed_relaxed${modifier}( + _ value: UnsafeAtomic<${type}>, + _ expected: ${type}, + _ desired: ${type} + ) -> (exchanged: Bool, original: ${type}) { + // CHECK: builtin "cmpxchg_monotonic_monotonic${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}${modifier}_${builtin}" + return value.${operation}( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_${label}_acquiring_relaxed${modifier}(_:_:_:) + public func compareExchange2_${label}_acquiring_relaxed${modifier}( + _ value: UnsafeAtomic<${type}>, + _ expected: ${type}, + _ desired: ${type} + ) -> (exchanged: Bool, original: ${type}) { + // CHECK: builtin "cmpxchg_acquire_monotonic${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}${modifier}_${builtin}" + return value.${operation}( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_${label}_acquiring_acquiring${modifier}(_:_:_:) + public func compareExchange2_${label}_acquiring_acquiring${modifier}( + _ value: UnsafeAtomic<${type}>, + _ expected: ${type}, + _ desired: ${type} + ) -> (exchanged: Bool, original: ${type}) { + // CHECK: builtin "cmpxchg_acquire_acquire${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}${modifier}_${builtin}" + return value.${operation}( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_${label}_sequential_acquiring${modifier}(_:_:_:) + public func compareExchange2_${label}_sequential_acquiring${modifier}( + _ value: UnsafeAtomic<${type}>, + _ expected: ${type}, + _ desired: ${type} + ) -> (exchanged: Bool, original: ${type}) { + // CHECK: builtin "cmpxchg_seqcst_acquire${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}${modifier}_${builtin}" + return value.${operation}( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_${label}_releasing_acquiring${modifier}(_:_:_:) + public func compareExchange2_${label}_releasing_acquiring${modifier}( + _ value: UnsafeAtomic<${type}>, + _ expected: ${type}, + _ desired: ${type} + ) -> (exchanged: Bool, original: ${type}) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}${modifier}_${builtin}" + return value.${operation}( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_${label}_relaxed_sequential${modifier}(_:_:_:) + public func compareExchange2_${label}_relaxed_sequential${modifier}( + _ value: UnsafeAtomic<${type}>, + _ expected: ${type}, + _ desired: ${type} + ) -> (exchanged: Bool, original: ${type}) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}${modifier}_${builtin}" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}${modifier}_${builtin}" + return value.${operation}( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + % end + % end + // --------------------------------------------------------------------------- + + % for (label, type, builtin) in integer_types: + % for (operation, llvmOp, argLabel) in integer_operations: + // SECTIONING-LABEL: // AtomicFoldingTests.${operation}_${label}_relaxed(_:_:) + public func ${operation}_${label}_relaxed( + _ value: UnsafeAtomic<${type}>, + _ operand: ${type} + ) -> ${type} { + // CHECK: builtin "atomicrmw_${llvmOp}_monotonic_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_${llvmOp}_acquire_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_${llvmOp}_release_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_${llvmOp}_acqrel_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_${llvmOp}_seqcst_${builtin}" + return value.${operation}(${argLabel}: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.${operation}_${label}_acquiring(_:_:) + public func ${operation}_${label}_acquiring( + _ value: UnsafeAtomic<${type}>, + _ operand: ${type} + ) -> ${type} { + // CHECK: builtin "atomicrmw_${llvmOp}_acquire_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_${llvmOp}_monotonic_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_${llvmOp}_release_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_${llvmOp}_acqrel_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_${llvmOp}_seqcst_${builtin}" + return value.${operation}(${argLabel}: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.${operation}_${label}_releasing(_:_:) + public func ${operation}_${label}_releasing( + _ value: UnsafeAtomic<${type}>, + _ operand: ${type} + ) -> ${type} { + // CHECK: builtin "atomicrmw_${llvmOp}_release_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_${llvmOp}_monotonic_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_${llvmOp}_acquire_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_${llvmOp}_acqrel_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_${llvmOp}_seqcst_${builtin}" + return value.${operation}(${argLabel}: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.${operation}_${label}_acquiringAndReleasing(_:_:) + public func ${operation}_${label}_acquiringAndReleasing( + _ value: UnsafeAtomic<${type}>, + _ operand: ${type} + ) -> ${type} { + // CHECK: builtin "atomicrmw_${llvmOp}_acqrel_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_${llvmOp}_monotonic_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_${llvmOp}_acquire_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_${llvmOp}_release_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_${llvmOp}_seqcst_${builtin}" + return value.${operation}( + ${argLabel}: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.${operation}_${label}_sequential(_:_:) + public func ${operation}_${label}_sequential( + _ value: UnsafeAtomic<${type}>, + _ operand: ${type} + ) -> ${type} { + // CHECK: builtin "atomicrmw_${llvmOp}_seqcst_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_${llvmOp}_monotonic_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_${llvmOp}_acquire_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_${llvmOp}_release_${builtin}" + // EXCLUSIONS-NOT: builtin "atomicrmw_${llvmOp}_acqrel_${builtin}" + return value.${operation}( + ${argLabel}: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + % end + % end + // --------------------------------------------------------------------------- +} diff --git a/Tests/lit/UnsafeAtomicInitializers.swift.gyb b/Tests/lit/UnsafeAtomicInitializers.swift.gyb new file mode 100644 index 0000000..2a3df4a --- /dev/null +++ b/Tests/lit/UnsafeAtomicInitializers.swift.gyb @@ -0,0 +1,170 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// +// RUN: %empty-directory(%t) +// RUN: %gyb %s -o %t/UnsafeAtomicInitializers.swift +// RUN: %line-directive %t/UnsafeAtomicInitializers.swift -- %target-swift-frontend -typecheck -verify %t/UnsafeAtomicInitializers.swift + +%{ + from gyb_utils import autogenerated_warning + + types = [ + # id type initial + ("Int", "Int", "0"), + ("Int64", "Int64", "0"), + ("Int32", "Int32", "0"), + ("Int16", "Int16", "0"), + ("Int8", "Int8", "0"), + ("UInt", "UInt", "0"), + ("UInt64", "UInt64", "0"), + ("UInt32", "UInt32", "0"), + ("UInt16", "UInt16", "0"), + ("UInt8", "UInt8", "0"), + + # id type initial + ("URP", "UnsafeRawPointer", "UnsafeRawPointer(UnsafeMutableRawPointer.allocate(byteCount: 8, alignment: 8))"), + ("UP", "UnsafePointer", "UnsafePointer(UnsafeMutablePointer.allocate(capacity: 1))"), + ("UMRP", "UnsafeMutableRawPointer", ".allocate(byteCount: 8, alignment: 8)"), + ("UMP", "UnsafeMutablePointer", ".allocate(capacity: 1)"), + ("Unmanaged", "Unmanaged", "Unmanaged.passRetained(Foo())"), + + # id type initial + ("URPOpt", "UnsafeRawPointer?", "nil"), + ("UPOpt", "UnsafePointer?", "nil"), + ("UMRPOpt", "UnsafeMutableRawPointer?", "nil"), + ("UMPOpt", "UnsafeMutablePointer?", "nil"), + ("UnmanagedOpt", "Unmanaged?", "nil"), + ] +}% +${autogenerated_warning()} + +import Atomics + +class Foo { + var value = 0 +} +struct Bar { + var value = 0 +} + +% for (id, type, initial) in types: +func test_${id}() -> UnsafeAtomic<${type}> { + var storage = UnsafeAtomic<${type}>.Storage(${initial}) + let atomic = UnsafeAtomic<${type}>(at: &storage) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomic<${type}>.Storage' to 'UnsafeMutablePointer.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + return atomic +} +% end + +func test_UnsafeAtomicLazyReference() -> UnsafeAtomicLazyReference { + var value = UnsafeAtomicLazyReference.Storage() + let atomic = UnsafeAtomicLazyReference(at: &value) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomicLazyReference.Storage' to 'UnsafeMutablePointer.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + return atomic +} + +class BrokenAtomicCounter { // THIS IS BROKEN; DO NOT USE + private var _storage = UnsafeAtomic.Storage(0) + private var _value: UnsafeAtomic? + + init() { + // This escapes the ephemeral pointer generated by the inout expression, + // so it leads to undefined behavior when the pointer gets dereferenced + // in the atomic operations below. DO NOT DO THIS. + _value = UnsafeAtomic(at: &_storage) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomic.Storage' to 'UnsafeMutablePointer.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + } + + func increment() { + _value!.wrappingIncrement(by: 1, ordering: .relaxed) + } + + func get() -> Int { + _value!.load(ordering: .relaxed) + } +} + +struct AtomicCounter { + typealias Value = Int + typealias Header = UnsafeAtomic.Storage + + class Buffer: ManagedBuffer { + deinit { + withUnsafeMutablePointerToHeader { header in + _ = header.pointee.dispose() + } + } + } + + let buffer: Buffer + + init() { + buffer = Buffer.create(minimumCapacity: 0) { _ in + Header(0) + } as! Buffer + } + + private func _withAtomicPointer( + _ body: (UnsafeAtomic) throws -> R + ) rethrows -> R { + try buffer.withUnsafeMutablePointerToHeader { header in + try body(UnsafeAtomic(at: header)) + } + } + + func increment() { + _withAtomicPointer { $0.wrappingIncrement(ordering: .relaxed) } + } + + func load() -> Int { + _withAtomicPointer { $0.load(ordering: .relaxed) } + } +} + +struct AtomicUnmanagedRef { + typealias Value = Unmanaged? + typealias Header = UnsafeAtomic.Storage + + class Buffer: ManagedBuffer { + deinit { + withUnsafeMutablePointerToHeader { header in + _ = header.pointee.dispose() + } + } + } + + let buffer: Buffer + + init() { + buffer = Buffer.create(minimumCapacity: 0) { _ in + Header(nil) + } as! Buffer + } + + private func _withAtomicPointer( + _ body: (UnsafeAtomic) throws -> R + ) rethrows -> R { + try buffer.withUnsafeMutablePointerToHeader { header in + try body(UnsafeAtomic(at: header)) + } + } + + func store(_ desired: Value) { + _withAtomicPointer { $0.store(desired, ordering: .sequentiallyConsistent) } + } + + func load() -> Value { + _withAtomicPointer { $0.load(ordering: .sequentiallyConsistent) } + } +} diff --git a/Tests/lit/autogenerated/AtomicsFolding.swift b/Tests/lit/autogenerated/AtomicsFolding.swift new file mode 100644 index 0000000..ef6ed87 --- /dev/null +++ b/Tests/lit/autogenerated/AtomicsFolding.swift @@ -0,0 +1,17205 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// +// RUN: %empty-directory(%t) +// RUN: %gyb %s > %t/AtomicsFolding.swift +// +// RUN: %target-swift-frontend -parse-as-library -emit-sil -Onone -module-name AtomicsFolding %t/AtomicsFolding.swift > %t/AtomicsFolding-Onone.sil +// RUN: %FileCheck --check-prefixes=SECTIONING,CHECK --input-file=%t/AtomicsFolding-Onone.sil %t/AtomicsFolding.swift +// RUN: %FileCheck --check-prefixes=SECTIONING,EXCLUSIONS --input-file=%t/AtomicsFolding-Onone.sil %t/AtomicsFolding.swift +// +// RUN: %target-swift-frontend -parse-as-library -emit-sil -O -module-name AtomicsFolding %t/AtomicsFolding.swift > %t/AtomicsFolding-O.sil +// RUN: %FileCheck --check-prefixes=SECTIONING,CHECK --input-file=%t/AtomicsFolding-O.sil %t/AtomicsFolding.swift +// RUN: %FileCheck --check-prefixes=SECTIONING,EXCLUSIONS --input-file=%t/AtomicsFolding-O.sil %t/AtomicsFolding.swift +// +// RUN: %target-swift-frontend -parse-as-library -emit-sil -Osize -module-name AtomicsFolding %t/AtomicsFolding.swift > %t/AtomicsFolding-Osize.sil +// RUN: %FileCheck --check-prefixes=SECTIONING,CHECK --input-file=%t/AtomicsFolding-Osize.sil %t/AtomicsFolding.swift +// RUN: %FileCheck --check-prefixes=SECTIONING,EXCLUSIONS --input-file=%t/AtomicsFolding-Osize.sil %t/AtomicsFolding.swift + +// Tests that atomic operations get compiled to the expected builtins, and only +// the expected builtins. (I.e., that the switch statements over the orderings +// get constant folded away.) + + +// ############################################################################# +// # # +// # DO NOT EDIT THIS FILE; IT IS AUTOGENERATED. # +// # # +// ############################################################################# + + +import Atomics + +public struct Foo {} +public class Bar {} + +// ----------------------------------------------------------------------------- + +public struct AtomicFoldingTests { + // SECTIONING-LABEL: // AtomicFoldingTests.load_Int_relaxed(_:) + public func load_Int_relaxed( + _ value: UnsafeAtomic + ) -> Int { + // CHECK: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_Int_acquiring(_:) + public func load_Int_acquiring( + _ value: UnsafeAtomic + ) -> Int { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // CHECK: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_Int_sequential(_:) + public func load_Int_sequential( + _ value: UnsafeAtomic + ) -> Int { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // CHECK: builtin "atomicload_seqcst_Word" + return value.load(ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_Int64_relaxed(_:) + public func load_Int64_relaxed( + _ value: UnsafeAtomic + ) -> Int64 { + // CHECK: builtin "atomicload_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Int64" + return value.load(ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_Int64_acquiring(_:) + public func load_Int64_acquiring( + _ value: UnsafeAtomic + ) -> Int64 { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Int64" + // CHECK: builtin "atomicload_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Int64" + return value.load(ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_Int64_sequential(_:) + public func load_Int64_sequential( + _ value: UnsafeAtomic + ) -> Int64 { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Int64" + // CHECK: builtin "atomicload_seqcst_Int64" + return value.load(ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_Int32_relaxed(_:) + public func load_Int32_relaxed( + _ value: UnsafeAtomic + ) -> Int32 { + // CHECK: builtin "atomicload_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Int32" + return value.load(ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_Int32_acquiring(_:) + public func load_Int32_acquiring( + _ value: UnsafeAtomic + ) -> Int32 { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Int32" + // CHECK: builtin "atomicload_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Int32" + return value.load(ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_Int32_sequential(_:) + public func load_Int32_sequential( + _ value: UnsafeAtomic + ) -> Int32 { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Int32" + // CHECK: builtin "atomicload_seqcst_Int32" + return value.load(ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_Int16_relaxed(_:) + public func load_Int16_relaxed( + _ value: UnsafeAtomic + ) -> Int16 { + // CHECK: builtin "atomicload_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Int16" + return value.load(ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_Int16_acquiring(_:) + public func load_Int16_acquiring( + _ value: UnsafeAtomic + ) -> Int16 { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Int16" + // CHECK: builtin "atomicload_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Int16" + return value.load(ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_Int16_sequential(_:) + public func load_Int16_sequential( + _ value: UnsafeAtomic + ) -> Int16 { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Int16" + // CHECK: builtin "atomicload_seqcst_Int16" + return value.load(ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_Int8_relaxed(_:) + public func load_Int8_relaxed( + _ value: UnsafeAtomic + ) -> Int8 { + // CHECK: builtin "atomicload_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Int8" + return value.load(ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_Int8_acquiring(_:) + public func load_Int8_acquiring( + _ value: UnsafeAtomic + ) -> Int8 { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Int8" + // CHECK: builtin "atomicload_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Int8" + return value.load(ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_Int8_sequential(_:) + public func load_Int8_sequential( + _ value: UnsafeAtomic + ) -> Int8 { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Int8" + // CHECK: builtin "atomicload_seqcst_Int8" + return value.load(ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UInt_relaxed(_:) + public func load_UInt_relaxed( + _ value: UnsafeAtomic + ) -> UInt { + // CHECK: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UInt_acquiring(_:) + public func load_UInt_acquiring( + _ value: UnsafeAtomic + ) -> UInt { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // CHECK: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UInt_sequential(_:) + public func load_UInt_sequential( + _ value: UnsafeAtomic + ) -> UInt { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // CHECK: builtin "atomicload_seqcst_Word" + return value.load(ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UInt64_relaxed(_:) + public func load_UInt64_relaxed( + _ value: UnsafeAtomic + ) -> UInt64 { + // CHECK: builtin "atomicload_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Int64" + return value.load(ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UInt64_acquiring(_:) + public func load_UInt64_acquiring( + _ value: UnsafeAtomic + ) -> UInt64 { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Int64" + // CHECK: builtin "atomicload_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Int64" + return value.load(ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UInt64_sequential(_:) + public func load_UInt64_sequential( + _ value: UnsafeAtomic + ) -> UInt64 { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Int64" + // CHECK: builtin "atomicload_seqcst_Int64" + return value.load(ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UInt32_relaxed(_:) + public func load_UInt32_relaxed( + _ value: UnsafeAtomic + ) -> UInt32 { + // CHECK: builtin "atomicload_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Int32" + return value.load(ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UInt32_acquiring(_:) + public func load_UInt32_acquiring( + _ value: UnsafeAtomic + ) -> UInt32 { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Int32" + // CHECK: builtin "atomicload_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Int32" + return value.load(ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UInt32_sequential(_:) + public func load_UInt32_sequential( + _ value: UnsafeAtomic + ) -> UInt32 { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Int32" + // CHECK: builtin "atomicload_seqcst_Int32" + return value.load(ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UInt16_relaxed(_:) + public func load_UInt16_relaxed( + _ value: UnsafeAtomic + ) -> UInt16 { + // CHECK: builtin "atomicload_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Int16" + return value.load(ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UInt16_acquiring(_:) + public func load_UInt16_acquiring( + _ value: UnsafeAtomic + ) -> UInt16 { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Int16" + // CHECK: builtin "atomicload_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Int16" + return value.load(ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UInt16_sequential(_:) + public func load_UInt16_sequential( + _ value: UnsafeAtomic + ) -> UInt16 { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Int16" + // CHECK: builtin "atomicload_seqcst_Int16" + return value.load(ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UInt8_relaxed(_:) + public func load_UInt8_relaxed( + _ value: UnsafeAtomic + ) -> UInt8 { + // CHECK: builtin "atomicload_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Int8" + return value.load(ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UInt8_acquiring(_:) + public func load_UInt8_acquiring( + _ value: UnsafeAtomic + ) -> UInt8 { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Int8" + // CHECK: builtin "atomicload_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Int8" + return value.load(ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UInt8_sequential(_:) + public func load_UInt8_sequential( + _ value: UnsafeAtomic + ) -> UInt8 { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Int8" + // CHECK: builtin "atomicload_seqcst_Int8" + return value.load(ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UnsafeRawPointer_relaxed(_:) + public func load_UnsafeRawPointer_relaxed( + _ value: UnsafeAtomic + ) -> UnsafeRawPointer { + // CHECK: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UnsafeRawPointer_acquiring(_:) + public func load_UnsafeRawPointer_acquiring( + _ value: UnsafeAtomic + ) -> UnsafeRawPointer { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // CHECK: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UnsafeRawPointer_sequential(_:) + public func load_UnsafeRawPointer_sequential( + _ value: UnsafeAtomic + ) -> UnsafeRawPointer { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // CHECK: builtin "atomicload_seqcst_Word" + return value.load(ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UnsafeMutableRawPointer_relaxed(_:) + public func load_UnsafeMutableRawPointer_relaxed( + _ value: UnsafeAtomic + ) -> UnsafeMutableRawPointer { + // CHECK: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UnsafeMutableRawPointer_acquiring(_:) + public func load_UnsafeMutableRawPointer_acquiring( + _ value: UnsafeAtomic + ) -> UnsafeMutableRawPointer { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // CHECK: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UnsafeMutableRawPointer_sequential(_:) + public func load_UnsafeMutableRawPointer_sequential( + _ value: UnsafeAtomic + ) -> UnsafeMutableRawPointer { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // CHECK: builtin "atomicload_seqcst_Word" + return value.load(ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UnsafePointer_relaxed(_:) + public func load_UnsafePointer_relaxed( + _ value: UnsafeAtomic> + ) -> UnsafePointer { + // CHECK: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UnsafePointer_acquiring(_:) + public func load_UnsafePointer_acquiring( + _ value: UnsafeAtomic> + ) -> UnsafePointer { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // CHECK: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UnsafePointer_sequential(_:) + public func load_UnsafePointer_sequential( + _ value: UnsafeAtomic> + ) -> UnsafePointer { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // CHECK: builtin "atomicload_seqcst_Word" + return value.load(ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UnsafeMutablePointer_relaxed(_:) + public func load_UnsafeMutablePointer_relaxed( + _ value: UnsafeAtomic> + ) -> UnsafeMutablePointer { + // CHECK: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UnsafeMutablePointer_acquiring(_:) + public func load_UnsafeMutablePointer_acquiring( + _ value: UnsafeAtomic> + ) -> UnsafeMutablePointer { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // CHECK: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_UnsafeMutablePointer_sequential(_:) + public func load_UnsafeMutablePointer_sequential( + _ value: UnsafeAtomic> + ) -> UnsafeMutablePointer { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // CHECK: builtin "atomicload_seqcst_Word" + return value.load(ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_Unmanaged_relaxed(_:) + public func load_Unmanaged_relaxed( + _ value: UnsafeAtomic> + ) -> Unmanaged { + // CHECK: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_Unmanaged_acquiring(_:) + public func load_Unmanaged_acquiring( + _ value: UnsafeAtomic> + ) -> Unmanaged { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // CHECK: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_Unmanaged_sequential(_:) + public func load_Unmanaged_sequential( + _ value: UnsafeAtomic> + ) -> Unmanaged { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // CHECK: builtin "atomicload_seqcst_Word" + return value.load(ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_OptionalUnsafeRawPointer_relaxed(_:) + public func load_OptionalUnsafeRawPointer_relaxed( + _ value: UnsafeAtomic> + ) -> Optional { + // CHECK: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_OptionalUnsafeRawPointer_acquiring(_:) + public func load_OptionalUnsafeRawPointer_acquiring( + _ value: UnsafeAtomic> + ) -> Optional { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // CHECK: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_OptionalUnsafeRawPointer_sequential(_:) + public func load_OptionalUnsafeRawPointer_sequential( + _ value: UnsafeAtomic> + ) -> Optional { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // CHECK: builtin "atomicload_seqcst_Word" + return value.load(ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_OptionalUnsafeMutableRawPointer_relaxed(_:) + public func load_OptionalUnsafeMutableRawPointer_relaxed( + _ value: UnsafeAtomic> + ) -> Optional { + // CHECK: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_OptionalUnsafeMutableRawPointer_acquiring(_:) + public func load_OptionalUnsafeMutableRawPointer_acquiring( + _ value: UnsafeAtomic> + ) -> Optional { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // CHECK: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_OptionalUnsafeMutableRawPointer_sequential(_:) + public func load_OptionalUnsafeMutableRawPointer_sequential( + _ value: UnsafeAtomic> + ) -> Optional { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // CHECK: builtin "atomicload_seqcst_Word" + return value.load(ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_OptionalUnsafePointer_relaxed(_:) + public func load_OptionalUnsafePointer_relaxed( + _ value: UnsafeAtomic>> + ) -> Optional> { + // CHECK: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_OptionalUnsafePointer_acquiring(_:) + public func load_OptionalUnsafePointer_acquiring( + _ value: UnsafeAtomic>> + ) -> Optional> { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // CHECK: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_OptionalUnsafePointer_sequential(_:) + public func load_OptionalUnsafePointer_sequential( + _ value: UnsafeAtomic>> + ) -> Optional> { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // CHECK: builtin "atomicload_seqcst_Word" + return value.load(ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_OptionalUnsafeMutablePointer_relaxed(_:) + public func load_OptionalUnsafeMutablePointer_relaxed( + _ value: UnsafeAtomic>> + ) -> Optional> { + // CHECK: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_OptionalUnsafeMutablePointer_acquiring(_:) + public func load_OptionalUnsafeMutablePointer_acquiring( + _ value: UnsafeAtomic>> + ) -> Optional> { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // CHECK: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_OptionalUnsafeMutablePointer_sequential(_:) + public func load_OptionalUnsafeMutablePointer_sequential( + _ value: UnsafeAtomic>> + ) -> Optional> { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // CHECK: builtin "atomicload_seqcst_Word" + return value.load(ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_OptionalUnmanaged_relaxed(_:) + public func load_OptionalUnmanaged_relaxed( + _ value: UnsafeAtomic>> + ) -> Optional> { + // CHECK: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_OptionalUnmanaged_acquiring(_:) + public func load_OptionalUnmanaged_acquiring( + _ value: UnsafeAtomic>> + ) -> Optional> { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // CHECK: builtin "atomicload_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicload_seqcst_Word" + return value.load(ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.load_OptionalUnmanaged_sequential(_:) + public func load_OptionalUnmanaged_sequential( + _ value: UnsafeAtomic>> + ) -> Optional> { + // EXCLUSIONS-NOT: builtin "atomicload_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicload_acquire_Word" + // CHECK: builtin "atomicload_seqcst_Word" + return value.load(ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // --------------------------------------------------------------------------- + + // SECTIONING-LABEL: // AtomicFoldingTests.store_Int_relaxed(_:_:) + public func store_Int_relaxed( + _ value: UnsafeAtomic, + _ desired: Int + ) { + // CHECK: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_Int_releasing(_:_:) + public func store_Int_releasing( + _ value: UnsafeAtomic, + _ desired: Int + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // CHECK: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_Int_sequential(_:_:) + public func store_Int_sequential( + _ value: UnsafeAtomic, + _ desired: Int + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // CHECK: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_Int64_relaxed(_:_:) + public func store_Int64_relaxed( + _ value: UnsafeAtomic, + _ desired: Int64 + ) { + // CHECK: builtin "atomicstore_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Int64" + value.store(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_Int64_releasing(_:_:) + public func store_Int64_releasing( + _ value: UnsafeAtomic, + _ desired: Int64 + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Int64" + // CHECK: builtin "atomicstore_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Int64" + value.store(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_Int64_sequential(_:_:) + public func store_Int64_sequential( + _ value: UnsafeAtomic, + _ desired: Int64 + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Int64" + // CHECK: builtin "atomicstore_seqcst_Int64" + value.store(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_Int32_relaxed(_:_:) + public func store_Int32_relaxed( + _ value: UnsafeAtomic, + _ desired: Int32 + ) { + // CHECK: builtin "atomicstore_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Int32" + value.store(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_Int32_releasing(_:_:) + public func store_Int32_releasing( + _ value: UnsafeAtomic, + _ desired: Int32 + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Int32" + // CHECK: builtin "atomicstore_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Int32" + value.store(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_Int32_sequential(_:_:) + public func store_Int32_sequential( + _ value: UnsafeAtomic, + _ desired: Int32 + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Int32" + // CHECK: builtin "atomicstore_seqcst_Int32" + value.store(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_Int16_relaxed(_:_:) + public func store_Int16_relaxed( + _ value: UnsafeAtomic, + _ desired: Int16 + ) { + // CHECK: builtin "atomicstore_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Int16" + value.store(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_Int16_releasing(_:_:) + public func store_Int16_releasing( + _ value: UnsafeAtomic, + _ desired: Int16 + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Int16" + // CHECK: builtin "atomicstore_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Int16" + value.store(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_Int16_sequential(_:_:) + public func store_Int16_sequential( + _ value: UnsafeAtomic, + _ desired: Int16 + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Int16" + // CHECK: builtin "atomicstore_seqcst_Int16" + value.store(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_Int8_relaxed(_:_:) + public func store_Int8_relaxed( + _ value: UnsafeAtomic, + _ desired: Int8 + ) { + // CHECK: builtin "atomicstore_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Int8" + value.store(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_Int8_releasing(_:_:) + public func store_Int8_releasing( + _ value: UnsafeAtomic, + _ desired: Int8 + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Int8" + // CHECK: builtin "atomicstore_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Int8" + value.store(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_Int8_sequential(_:_:) + public func store_Int8_sequential( + _ value: UnsafeAtomic, + _ desired: Int8 + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Int8" + // CHECK: builtin "atomicstore_seqcst_Int8" + value.store(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UInt_relaxed(_:_:) + public func store_UInt_relaxed( + _ value: UnsafeAtomic, + _ desired: UInt + ) { + // CHECK: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UInt_releasing(_:_:) + public func store_UInt_releasing( + _ value: UnsafeAtomic, + _ desired: UInt + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // CHECK: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UInt_sequential(_:_:) + public func store_UInt_sequential( + _ value: UnsafeAtomic, + _ desired: UInt + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // CHECK: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UInt64_relaxed(_:_:) + public func store_UInt64_relaxed( + _ value: UnsafeAtomic, + _ desired: UInt64 + ) { + // CHECK: builtin "atomicstore_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Int64" + value.store(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UInt64_releasing(_:_:) + public func store_UInt64_releasing( + _ value: UnsafeAtomic, + _ desired: UInt64 + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Int64" + // CHECK: builtin "atomicstore_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Int64" + value.store(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UInt64_sequential(_:_:) + public func store_UInt64_sequential( + _ value: UnsafeAtomic, + _ desired: UInt64 + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Int64" + // CHECK: builtin "atomicstore_seqcst_Int64" + value.store(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UInt32_relaxed(_:_:) + public func store_UInt32_relaxed( + _ value: UnsafeAtomic, + _ desired: UInt32 + ) { + // CHECK: builtin "atomicstore_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Int32" + value.store(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UInt32_releasing(_:_:) + public func store_UInt32_releasing( + _ value: UnsafeAtomic, + _ desired: UInt32 + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Int32" + // CHECK: builtin "atomicstore_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Int32" + value.store(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UInt32_sequential(_:_:) + public func store_UInt32_sequential( + _ value: UnsafeAtomic, + _ desired: UInt32 + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Int32" + // CHECK: builtin "atomicstore_seqcst_Int32" + value.store(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UInt16_relaxed(_:_:) + public func store_UInt16_relaxed( + _ value: UnsafeAtomic, + _ desired: UInt16 + ) { + // CHECK: builtin "atomicstore_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Int16" + value.store(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UInt16_releasing(_:_:) + public func store_UInt16_releasing( + _ value: UnsafeAtomic, + _ desired: UInt16 + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Int16" + // CHECK: builtin "atomicstore_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Int16" + value.store(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UInt16_sequential(_:_:) + public func store_UInt16_sequential( + _ value: UnsafeAtomic, + _ desired: UInt16 + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Int16" + // CHECK: builtin "atomicstore_seqcst_Int16" + value.store(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UInt8_relaxed(_:_:) + public func store_UInt8_relaxed( + _ value: UnsafeAtomic, + _ desired: UInt8 + ) { + // CHECK: builtin "atomicstore_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Int8" + value.store(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UInt8_releasing(_:_:) + public func store_UInt8_releasing( + _ value: UnsafeAtomic, + _ desired: UInt8 + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Int8" + // CHECK: builtin "atomicstore_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Int8" + value.store(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UInt8_sequential(_:_:) + public func store_UInt8_sequential( + _ value: UnsafeAtomic, + _ desired: UInt8 + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Int8" + // CHECK: builtin "atomicstore_seqcst_Int8" + value.store(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UnsafeRawPointer_relaxed(_:_:) + public func store_UnsafeRawPointer_relaxed( + _ value: UnsafeAtomic, + _ desired: UnsafeRawPointer + ) { + // CHECK: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UnsafeRawPointer_releasing(_:_:) + public func store_UnsafeRawPointer_releasing( + _ value: UnsafeAtomic, + _ desired: UnsafeRawPointer + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // CHECK: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UnsafeRawPointer_sequential(_:_:) + public func store_UnsafeRawPointer_sequential( + _ value: UnsafeAtomic, + _ desired: UnsafeRawPointer + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // CHECK: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UnsafeMutableRawPointer_relaxed(_:_:) + public func store_UnsafeMutableRawPointer_relaxed( + _ value: UnsafeAtomic, + _ desired: UnsafeMutableRawPointer + ) { + // CHECK: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UnsafeMutableRawPointer_releasing(_:_:) + public func store_UnsafeMutableRawPointer_releasing( + _ value: UnsafeAtomic, + _ desired: UnsafeMutableRawPointer + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // CHECK: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UnsafeMutableRawPointer_sequential(_:_:) + public func store_UnsafeMutableRawPointer_sequential( + _ value: UnsafeAtomic, + _ desired: UnsafeMutableRawPointer + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // CHECK: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UnsafePointer_relaxed(_:_:) + public func store_UnsafePointer_relaxed( + _ value: UnsafeAtomic>, + _ desired: UnsafePointer + ) { + // CHECK: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UnsafePointer_releasing(_:_:) + public func store_UnsafePointer_releasing( + _ value: UnsafeAtomic>, + _ desired: UnsafePointer + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // CHECK: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UnsafePointer_sequential(_:_:) + public func store_UnsafePointer_sequential( + _ value: UnsafeAtomic>, + _ desired: UnsafePointer + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // CHECK: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UnsafeMutablePointer_relaxed(_:_:) + public func store_UnsafeMutablePointer_relaxed( + _ value: UnsafeAtomic>, + _ desired: UnsafeMutablePointer + ) { + // CHECK: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UnsafeMutablePointer_releasing(_:_:) + public func store_UnsafeMutablePointer_releasing( + _ value: UnsafeAtomic>, + _ desired: UnsafeMutablePointer + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // CHECK: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_UnsafeMutablePointer_sequential(_:_:) + public func store_UnsafeMutablePointer_sequential( + _ value: UnsafeAtomic>, + _ desired: UnsafeMutablePointer + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // CHECK: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_Unmanaged_relaxed(_:_:) + public func store_Unmanaged_relaxed( + _ value: UnsafeAtomic>, + _ desired: Unmanaged + ) { + // CHECK: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_Unmanaged_releasing(_:_:) + public func store_Unmanaged_releasing( + _ value: UnsafeAtomic>, + _ desired: Unmanaged + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // CHECK: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_Unmanaged_sequential(_:_:) + public func store_Unmanaged_sequential( + _ value: UnsafeAtomic>, + _ desired: Unmanaged + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // CHECK: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_OptionalUnsafeRawPointer_relaxed(_:_:) + public func store_OptionalUnsafeRawPointer_relaxed( + _ value: UnsafeAtomic>, + _ desired: Optional + ) { + // CHECK: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_OptionalUnsafeRawPointer_releasing(_:_:) + public func store_OptionalUnsafeRawPointer_releasing( + _ value: UnsafeAtomic>, + _ desired: Optional + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // CHECK: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_OptionalUnsafeRawPointer_sequential(_:_:) + public func store_OptionalUnsafeRawPointer_sequential( + _ value: UnsafeAtomic>, + _ desired: Optional + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // CHECK: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_OptionalUnsafeMutableRawPointer_relaxed(_:_:) + public func store_OptionalUnsafeMutableRawPointer_relaxed( + _ value: UnsafeAtomic>, + _ desired: Optional + ) { + // CHECK: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_OptionalUnsafeMutableRawPointer_releasing(_:_:) + public func store_OptionalUnsafeMutableRawPointer_releasing( + _ value: UnsafeAtomic>, + _ desired: Optional + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // CHECK: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_OptionalUnsafeMutableRawPointer_sequential(_:_:) + public func store_OptionalUnsafeMutableRawPointer_sequential( + _ value: UnsafeAtomic>, + _ desired: Optional + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // CHECK: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_OptionalUnsafePointer_relaxed(_:_:) + public func store_OptionalUnsafePointer_relaxed( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) { + // CHECK: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_OptionalUnsafePointer_releasing(_:_:) + public func store_OptionalUnsafePointer_releasing( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // CHECK: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_OptionalUnsafePointer_sequential(_:_:) + public func store_OptionalUnsafePointer_sequential( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // CHECK: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_OptionalUnsafeMutablePointer_relaxed(_:_:) + public func store_OptionalUnsafeMutablePointer_relaxed( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) { + // CHECK: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_OptionalUnsafeMutablePointer_releasing(_:_:) + public func store_OptionalUnsafeMutablePointer_releasing( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // CHECK: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_OptionalUnsafeMutablePointer_sequential(_:_:) + public func store_OptionalUnsafeMutablePointer_sequential( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // CHECK: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_OptionalUnmanaged_relaxed(_:_:) + public func store_OptionalUnmanaged_relaxed( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) { + // CHECK: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_OptionalUnmanaged_releasing(_:_:) + public func store_OptionalUnmanaged_releasing( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // CHECK: builtin "atomicstore_release_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.store_OptionalUnmanaged_sequential(_:_:) + public func store_OptionalUnmanaged_sequential( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) { + // EXCLUSIONS-NOT: builtin "atomicstore_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicstore_release_Word" + // CHECK: builtin "atomicstore_seqcst_Word" + value.store(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // --------------------------------------------------------------------------- + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int_relaxed(_:_:) + public func exchange_Int_relaxed( + _ value: UnsafeAtomic, + _ desired: Int + ) -> Int { + // CHECK: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int_acquiring(_:_:) + public func exchange_Int_acquiring( + _ value: UnsafeAtomic, + _ desired: Int + ) -> Int { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // CHECK: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int_releasing(_:_:) + public func exchange_Int_releasing( + _ value: UnsafeAtomic, + _ desired: Int + ) -> Int { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // CHECK: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int_acquiringAndReleasing(_:_:) + public func exchange_Int_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ desired: Int + ) -> Int { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // CHECK: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int_sequential(_:_:) + public func exchange_Int_sequential( + _ value: UnsafeAtomic, + _ desired: Int + ) -> Int { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // CHECK: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int64_relaxed(_:_:) + public func exchange_Int64_relaxed( + _ value: UnsafeAtomic, + _ desired: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_xchg_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int64" + return value.exchange(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int64_acquiring(_:_:) + public func exchange_Int64_acquiring( + _ value: UnsafeAtomic, + _ desired: Int64 + ) -> Int64 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int64" + // CHECK: builtin "atomicrmw_xchg_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int64" + return value.exchange(desired, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int64_releasing(_:_:) + public func exchange_Int64_releasing( + _ value: UnsafeAtomic, + _ desired: Int64 + ) -> Int64 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int64" + // CHECK: builtin "atomicrmw_xchg_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int64" + return value.exchange(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int64_acquiringAndReleasing(_:_:) + public func exchange_Int64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ desired: Int64 + ) -> Int64 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int64" + // CHECK: builtin "atomicrmw_xchg_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int64" + return value.exchange(desired, ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int64_sequential(_:_:) + public func exchange_Int64_sequential( + _ value: UnsafeAtomic, + _ desired: Int64 + ) -> Int64 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int64" + // CHECK: builtin "atomicrmw_xchg_seqcst_Int64" + return value.exchange(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int32_relaxed(_:_:) + public func exchange_Int32_relaxed( + _ value: UnsafeAtomic, + _ desired: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_xchg_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int32" + return value.exchange(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int32_acquiring(_:_:) + public func exchange_Int32_acquiring( + _ value: UnsafeAtomic, + _ desired: Int32 + ) -> Int32 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int32" + // CHECK: builtin "atomicrmw_xchg_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int32" + return value.exchange(desired, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int32_releasing(_:_:) + public func exchange_Int32_releasing( + _ value: UnsafeAtomic, + _ desired: Int32 + ) -> Int32 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int32" + // CHECK: builtin "atomicrmw_xchg_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int32" + return value.exchange(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int32_acquiringAndReleasing(_:_:) + public func exchange_Int32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ desired: Int32 + ) -> Int32 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int32" + // CHECK: builtin "atomicrmw_xchg_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int32" + return value.exchange(desired, ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int32_sequential(_:_:) + public func exchange_Int32_sequential( + _ value: UnsafeAtomic, + _ desired: Int32 + ) -> Int32 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int32" + // CHECK: builtin "atomicrmw_xchg_seqcst_Int32" + return value.exchange(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int16_relaxed(_:_:) + public func exchange_Int16_relaxed( + _ value: UnsafeAtomic, + _ desired: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_xchg_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int16" + return value.exchange(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int16_acquiring(_:_:) + public func exchange_Int16_acquiring( + _ value: UnsafeAtomic, + _ desired: Int16 + ) -> Int16 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int16" + // CHECK: builtin "atomicrmw_xchg_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int16" + return value.exchange(desired, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int16_releasing(_:_:) + public func exchange_Int16_releasing( + _ value: UnsafeAtomic, + _ desired: Int16 + ) -> Int16 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int16" + // CHECK: builtin "atomicrmw_xchg_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int16" + return value.exchange(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int16_acquiringAndReleasing(_:_:) + public func exchange_Int16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ desired: Int16 + ) -> Int16 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int16" + // CHECK: builtin "atomicrmw_xchg_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int16" + return value.exchange(desired, ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int16_sequential(_:_:) + public func exchange_Int16_sequential( + _ value: UnsafeAtomic, + _ desired: Int16 + ) -> Int16 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int16" + // CHECK: builtin "atomicrmw_xchg_seqcst_Int16" + return value.exchange(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int8_relaxed(_:_:) + public func exchange_Int8_relaxed( + _ value: UnsafeAtomic, + _ desired: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_xchg_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int8" + return value.exchange(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int8_acquiring(_:_:) + public func exchange_Int8_acquiring( + _ value: UnsafeAtomic, + _ desired: Int8 + ) -> Int8 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int8" + // CHECK: builtin "atomicrmw_xchg_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int8" + return value.exchange(desired, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int8_releasing(_:_:) + public func exchange_Int8_releasing( + _ value: UnsafeAtomic, + _ desired: Int8 + ) -> Int8 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int8" + // CHECK: builtin "atomicrmw_xchg_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int8" + return value.exchange(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int8_acquiringAndReleasing(_:_:) + public func exchange_Int8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ desired: Int8 + ) -> Int8 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int8" + // CHECK: builtin "atomicrmw_xchg_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int8" + return value.exchange(desired, ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Int8_sequential(_:_:) + public func exchange_Int8_sequential( + _ value: UnsafeAtomic, + _ desired: Int8 + ) -> Int8 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int8" + // CHECK: builtin "atomicrmw_xchg_seqcst_Int8" + return value.exchange(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt_relaxed(_:_:) + public func exchange_UInt_relaxed( + _ value: UnsafeAtomic, + _ desired: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt_acquiring(_:_:) + public func exchange_UInt_acquiring( + _ value: UnsafeAtomic, + _ desired: UInt + ) -> UInt { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // CHECK: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt_releasing(_:_:) + public func exchange_UInt_releasing( + _ value: UnsafeAtomic, + _ desired: UInt + ) -> UInt { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // CHECK: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt_acquiringAndReleasing(_:_:) + public func exchange_UInt_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ desired: UInt + ) -> UInt { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // CHECK: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt_sequential(_:_:) + public func exchange_UInt_sequential( + _ value: UnsafeAtomic, + _ desired: UInt + ) -> UInt { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // CHECK: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt64_relaxed(_:_:) + public func exchange_UInt64_relaxed( + _ value: UnsafeAtomic, + _ desired: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_xchg_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int64" + return value.exchange(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt64_acquiring(_:_:) + public func exchange_UInt64_acquiring( + _ value: UnsafeAtomic, + _ desired: UInt64 + ) -> UInt64 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int64" + // CHECK: builtin "atomicrmw_xchg_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int64" + return value.exchange(desired, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt64_releasing(_:_:) + public func exchange_UInt64_releasing( + _ value: UnsafeAtomic, + _ desired: UInt64 + ) -> UInt64 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int64" + // CHECK: builtin "atomicrmw_xchg_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int64" + return value.exchange(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt64_acquiringAndReleasing(_:_:) + public func exchange_UInt64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ desired: UInt64 + ) -> UInt64 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int64" + // CHECK: builtin "atomicrmw_xchg_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int64" + return value.exchange(desired, ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt64_sequential(_:_:) + public func exchange_UInt64_sequential( + _ value: UnsafeAtomic, + _ desired: UInt64 + ) -> UInt64 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int64" + // CHECK: builtin "atomicrmw_xchg_seqcst_Int64" + return value.exchange(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt32_relaxed(_:_:) + public func exchange_UInt32_relaxed( + _ value: UnsafeAtomic, + _ desired: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_xchg_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int32" + return value.exchange(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt32_acquiring(_:_:) + public func exchange_UInt32_acquiring( + _ value: UnsafeAtomic, + _ desired: UInt32 + ) -> UInt32 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int32" + // CHECK: builtin "atomicrmw_xchg_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int32" + return value.exchange(desired, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt32_releasing(_:_:) + public func exchange_UInt32_releasing( + _ value: UnsafeAtomic, + _ desired: UInt32 + ) -> UInt32 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int32" + // CHECK: builtin "atomicrmw_xchg_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int32" + return value.exchange(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt32_acquiringAndReleasing(_:_:) + public func exchange_UInt32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ desired: UInt32 + ) -> UInt32 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int32" + // CHECK: builtin "atomicrmw_xchg_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int32" + return value.exchange(desired, ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt32_sequential(_:_:) + public func exchange_UInt32_sequential( + _ value: UnsafeAtomic, + _ desired: UInt32 + ) -> UInt32 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int32" + // CHECK: builtin "atomicrmw_xchg_seqcst_Int32" + return value.exchange(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt16_relaxed(_:_:) + public func exchange_UInt16_relaxed( + _ value: UnsafeAtomic, + _ desired: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_xchg_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int16" + return value.exchange(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt16_acquiring(_:_:) + public func exchange_UInt16_acquiring( + _ value: UnsafeAtomic, + _ desired: UInt16 + ) -> UInt16 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int16" + // CHECK: builtin "atomicrmw_xchg_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int16" + return value.exchange(desired, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt16_releasing(_:_:) + public func exchange_UInt16_releasing( + _ value: UnsafeAtomic, + _ desired: UInt16 + ) -> UInt16 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int16" + // CHECK: builtin "atomicrmw_xchg_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int16" + return value.exchange(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt16_acquiringAndReleasing(_:_:) + public func exchange_UInt16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ desired: UInt16 + ) -> UInt16 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int16" + // CHECK: builtin "atomicrmw_xchg_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int16" + return value.exchange(desired, ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt16_sequential(_:_:) + public func exchange_UInt16_sequential( + _ value: UnsafeAtomic, + _ desired: UInt16 + ) -> UInt16 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int16" + // CHECK: builtin "atomicrmw_xchg_seqcst_Int16" + return value.exchange(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt8_relaxed(_:_:) + public func exchange_UInt8_relaxed( + _ value: UnsafeAtomic, + _ desired: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_xchg_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int8" + return value.exchange(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt8_acquiring(_:_:) + public func exchange_UInt8_acquiring( + _ value: UnsafeAtomic, + _ desired: UInt8 + ) -> UInt8 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int8" + // CHECK: builtin "atomicrmw_xchg_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int8" + return value.exchange(desired, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt8_releasing(_:_:) + public func exchange_UInt8_releasing( + _ value: UnsafeAtomic, + _ desired: UInt8 + ) -> UInt8 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int8" + // CHECK: builtin "atomicrmw_xchg_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int8" + return value.exchange(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt8_acquiringAndReleasing(_:_:) + public func exchange_UInt8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ desired: UInt8 + ) -> UInt8 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int8" + // CHECK: builtin "atomicrmw_xchg_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Int8" + return value.exchange(desired, ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UInt8_sequential(_:_:) + public func exchange_UInt8_sequential( + _ value: UnsafeAtomic, + _ desired: UInt8 + ) -> UInt8 { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Int8" + // CHECK: builtin "atomicrmw_xchg_seqcst_Int8" + return value.exchange(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UnsafeRawPointer_relaxed(_:_:) + public func exchange_UnsafeRawPointer_relaxed( + _ value: UnsafeAtomic, + _ desired: UnsafeRawPointer + ) -> UnsafeRawPointer { + // CHECK: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UnsafeRawPointer_acquiring(_:_:) + public func exchange_UnsafeRawPointer_acquiring( + _ value: UnsafeAtomic, + _ desired: UnsafeRawPointer + ) -> UnsafeRawPointer { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // CHECK: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UnsafeRawPointer_releasing(_:_:) + public func exchange_UnsafeRawPointer_releasing( + _ value: UnsafeAtomic, + _ desired: UnsafeRawPointer + ) -> UnsafeRawPointer { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // CHECK: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UnsafeRawPointer_acquiringAndReleasing(_:_:) + public func exchange_UnsafeRawPointer_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ desired: UnsafeRawPointer + ) -> UnsafeRawPointer { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // CHECK: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UnsafeRawPointer_sequential(_:_:) + public func exchange_UnsafeRawPointer_sequential( + _ value: UnsafeAtomic, + _ desired: UnsafeRawPointer + ) -> UnsafeRawPointer { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // CHECK: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UnsafeMutableRawPointer_relaxed(_:_:) + public func exchange_UnsafeMutableRawPointer_relaxed( + _ value: UnsafeAtomic, + _ desired: UnsafeMutableRawPointer + ) -> UnsafeMutableRawPointer { + // CHECK: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UnsafeMutableRawPointer_acquiring(_:_:) + public func exchange_UnsafeMutableRawPointer_acquiring( + _ value: UnsafeAtomic, + _ desired: UnsafeMutableRawPointer + ) -> UnsafeMutableRawPointer { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // CHECK: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UnsafeMutableRawPointer_releasing(_:_:) + public func exchange_UnsafeMutableRawPointer_releasing( + _ value: UnsafeAtomic, + _ desired: UnsafeMutableRawPointer + ) -> UnsafeMutableRawPointer { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // CHECK: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UnsafeMutableRawPointer_acquiringAndReleasing(_:_:) + public func exchange_UnsafeMutableRawPointer_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ desired: UnsafeMutableRawPointer + ) -> UnsafeMutableRawPointer { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // CHECK: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UnsafeMutableRawPointer_sequential(_:_:) + public func exchange_UnsafeMutableRawPointer_sequential( + _ value: UnsafeAtomic, + _ desired: UnsafeMutableRawPointer + ) -> UnsafeMutableRawPointer { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // CHECK: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UnsafePointer_relaxed(_:_:) + public func exchange_UnsafePointer_relaxed( + _ value: UnsafeAtomic>, + _ desired: UnsafePointer + ) -> UnsafePointer { + // CHECK: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UnsafePointer_acquiring(_:_:) + public func exchange_UnsafePointer_acquiring( + _ value: UnsafeAtomic>, + _ desired: UnsafePointer + ) -> UnsafePointer { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // CHECK: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UnsafePointer_releasing(_:_:) + public func exchange_UnsafePointer_releasing( + _ value: UnsafeAtomic>, + _ desired: UnsafePointer + ) -> UnsafePointer { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // CHECK: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UnsafePointer_acquiringAndReleasing(_:_:) + public func exchange_UnsafePointer_acquiringAndReleasing( + _ value: UnsafeAtomic>, + _ desired: UnsafePointer + ) -> UnsafePointer { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // CHECK: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UnsafePointer_sequential(_:_:) + public func exchange_UnsafePointer_sequential( + _ value: UnsafeAtomic>, + _ desired: UnsafePointer + ) -> UnsafePointer { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // CHECK: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UnsafeMutablePointer_relaxed(_:_:) + public func exchange_UnsafeMutablePointer_relaxed( + _ value: UnsafeAtomic>, + _ desired: UnsafeMutablePointer + ) -> UnsafeMutablePointer { + // CHECK: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UnsafeMutablePointer_acquiring(_:_:) + public func exchange_UnsafeMutablePointer_acquiring( + _ value: UnsafeAtomic>, + _ desired: UnsafeMutablePointer + ) -> UnsafeMutablePointer { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // CHECK: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UnsafeMutablePointer_releasing(_:_:) + public func exchange_UnsafeMutablePointer_releasing( + _ value: UnsafeAtomic>, + _ desired: UnsafeMutablePointer + ) -> UnsafeMutablePointer { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // CHECK: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UnsafeMutablePointer_acquiringAndReleasing(_:_:) + public func exchange_UnsafeMutablePointer_acquiringAndReleasing( + _ value: UnsafeAtomic>, + _ desired: UnsafeMutablePointer + ) -> UnsafeMutablePointer { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // CHECK: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_UnsafeMutablePointer_sequential(_:_:) + public func exchange_UnsafeMutablePointer_sequential( + _ value: UnsafeAtomic>, + _ desired: UnsafeMutablePointer + ) -> UnsafeMutablePointer { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // CHECK: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Unmanaged_relaxed(_:_:) + public func exchange_Unmanaged_relaxed( + _ value: UnsafeAtomic>, + _ desired: Unmanaged + ) -> Unmanaged { + // CHECK: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Unmanaged_acquiring(_:_:) + public func exchange_Unmanaged_acquiring( + _ value: UnsafeAtomic>, + _ desired: Unmanaged + ) -> Unmanaged { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // CHECK: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Unmanaged_releasing(_:_:) + public func exchange_Unmanaged_releasing( + _ value: UnsafeAtomic>, + _ desired: Unmanaged + ) -> Unmanaged { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // CHECK: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Unmanaged_acquiringAndReleasing(_:_:) + public func exchange_Unmanaged_acquiringAndReleasing( + _ value: UnsafeAtomic>, + _ desired: Unmanaged + ) -> Unmanaged { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // CHECK: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_Unmanaged_sequential(_:_:) + public func exchange_Unmanaged_sequential( + _ value: UnsafeAtomic>, + _ desired: Unmanaged + ) -> Unmanaged { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // CHECK: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnsafeRawPointer_relaxed(_:_:) + public func exchange_OptionalUnsafeRawPointer_relaxed( + _ value: UnsafeAtomic>, + _ desired: Optional + ) -> Optional { + // CHECK: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnsafeRawPointer_acquiring(_:_:) + public func exchange_OptionalUnsafeRawPointer_acquiring( + _ value: UnsafeAtomic>, + _ desired: Optional + ) -> Optional { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // CHECK: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnsafeRawPointer_releasing(_:_:) + public func exchange_OptionalUnsafeRawPointer_releasing( + _ value: UnsafeAtomic>, + _ desired: Optional + ) -> Optional { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // CHECK: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnsafeRawPointer_acquiringAndReleasing(_:_:) + public func exchange_OptionalUnsafeRawPointer_acquiringAndReleasing( + _ value: UnsafeAtomic>, + _ desired: Optional + ) -> Optional { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // CHECK: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnsafeRawPointer_sequential(_:_:) + public func exchange_OptionalUnsafeRawPointer_sequential( + _ value: UnsafeAtomic>, + _ desired: Optional + ) -> Optional { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // CHECK: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnsafeMutableRawPointer_relaxed(_:_:) + public func exchange_OptionalUnsafeMutableRawPointer_relaxed( + _ value: UnsafeAtomic>, + _ desired: Optional + ) -> Optional { + // CHECK: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnsafeMutableRawPointer_acquiring(_:_:) + public func exchange_OptionalUnsafeMutableRawPointer_acquiring( + _ value: UnsafeAtomic>, + _ desired: Optional + ) -> Optional { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // CHECK: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnsafeMutableRawPointer_releasing(_:_:) + public func exchange_OptionalUnsafeMutableRawPointer_releasing( + _ value: UnsafeAtomic>, + _ desired: Optional + ) -> Optional { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // CHECK: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnsafeMutableRawPointer_acquiringAndReleasing(_:_:) + public func exchange_OptionalUnsafeMutableRawPointer_acquiringAndReleasing( + _ value: UnsafeAtomic>, + _ desired: Optional + ) -> Optional { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // CHECK: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnsafeMutableRawPointer_sequential(_:_:) + public func exchange_OptionalUnsafeMutableRawPointer_sequential( + _ value: UnsafeAtomic>, + _ desired: Optional + ) -> Optional { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // CHECK: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnsafePointer_relaxed(_:_:) + public func exchange_OptionalUnsafePointer_relaxed( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) -> Optional> { + // CHECK: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnsafePointer_acquiring(_:_:) + public func exchange_OptionalUnsafePointer_acquiring( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) -> Optional> { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // CHECK: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnsafePointer_releasing(_:_:) + public func exchange_OptionalUnsafePointer_releasing( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) -> Optional> { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // CHECK: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnsafePointer_acquiringAndReleasing(_:_:) + public func exchange_OptionalUnsafePointer_acquiringAndReleasing( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) -> Optional> { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // CHECK: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnsafePointer_sequential(_:_:) + public func exchange_OptionalUnsafePointer_sequential( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) -> Optional> { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // CHECK: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnsafeMutablePointer_relaxed(_:_:) + public func exchange_OptionalUnsafeMutablePointer_relaxed( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) -> Optional> { + // CHECK: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnsafeMutablePointer_acquiring(_:_:) + public func exchange_OptionalUnsafeMutablePointer_acquiring( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) -> Optional> { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // CHECK: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnsafeMutablePointer_releasing(_:_:) + public func exchange_OptionalUnsafeMutablePointer_releasing( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) -> Optional> { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // CHECK: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnsafeMutablePointer_acquiringAndReleasing(_:_:) + public func exchange_OptionalUnsafeMutablePointer_acquiringAndReleasing( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) -> Optional> { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // CHECK: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnsafeMutablePointer_sequential(_:_:) + public func exchange_OptionalUnsafeMutablePointer_sequential( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) -> Optional> { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // CHECK: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnmanaged_relaxed(_:_:) + public func exchange_OptionalUnmanaged_relaxed( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) -> Optional> { + // CHECK: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnmanaged_acquiring(_:_:) + public func exchange_OptionalUnmanaged_acquiring( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) -> Optional> { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // CHECK: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnmanaged_releasing(_:_:) + public func exchange_OptionalUnmanaged_releasing( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) -> Optional> { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // CHECK: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnmanaged_acquiringAndReleasing(_:_:) + public func exchange_OptionalUnmanaged_acquiringAndReleasing( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) -> Optional> { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // CHECK: builtin "atomicrmw_xchg_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.exchange_OptionalUnmanaged_sequential(_:_:) + public func exchange_OptionalUnmanaged_sequential( + _ value: UnsafeAtomic>>, + _ desired: Optional> + ) -> Optional> { + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xchg_acqrel_Word" + // CHECK: builtin "atomicrmw_xchg_seqcst_Word" + return value.exchange(desired, ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // --------------------------------------------------------------------------- + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int_relaxed(_:_:_:) + public func compareExchange_Int_relaxed( + _ value: UnsafeAtomic, + _ expected: Int, + _ desired: Int + ) -> (exchanged: Bool, original: Int) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int_acquiring(_:_:_:) + public func compareExchange_Int_acquiring( + _ value: UnsafeAtomic, + _ expected: Int, + _ desired: Int + ) -> (exchanged: Bool, original: Int) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int_releasing(_:_:_:) + public func compareExchange_Int_releasing( + _ value: UnsafeAtomic, + _ expected: Int, + _ desired: Int + ) -> (exchanged: Bool, original: Int) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_release_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int_acquiringAndReleasing(_:_:_:) + public func compareExchange_Int_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ expected: Int, + _ desired: Int + ) -> (exchanged: Bool, original: Int) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int_sequential(_:_:_:) + public func compareExchange_Int_sequential( + _ value: UnsafeAtomic, + _ expected: Int, + _ desired: Int + ) -> (exchanged: Bool, original: Int) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int64_relaxed(_:_:_:) + public func compareExchange_Int64_relaxed( + _ value: UnsafeAtomic, + _ expected: Int64, + _ desired: Int64 + ) -> (exchanged: Bool, original: Int64) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int64" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int64_acquiring(_:_:_:) + public func compareExchange_Int64_acquiring( + _ value: UnsafeAtomic, + _ expected: Int64, + _ desired: Int64 + ) -> (exchanged: Bool, original: Int64) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int64" + // CHECK: builtin "cmpxchg_acquire_acquire_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int64" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int64_releasing(_:_:_:) + public func compareExchange_Int64_releasing( + _ value: UnsafeAtomic, + _ expected: Int64, + _ desired: Int64 + ) -> (exchanged: Bool, original: Int64) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int64" + // CHECK: builtin "cmpxchg_release_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int64" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int64_acquiringAndReleasing(_:_:_:) + public func compareExchange_Int64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ expected: Int64, + _ desired: Int64 + ) -> (exchanged: Bool, original: Int64) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int64" + // CHECK: builtin "cmpxchg_acqrel_acquire_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int64" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int64_sequential(_:_:_:) + public func compareExchange_Int64_sequential( + _ value: UnsafeAtomic, + _ expected: Int64, + _ desired: Int64 + ) -> (exchanged: Bool, original: Int64) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int64" + // CHECK: builtin "cmpxchg_seqcst_seqcst_Int64" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int32_relaxed(_:_:_:) + public func compareExchange_Int32_relaxed( + _ value: UnsafeAtomic, + _ expected: Int32, + _ desired: Int32 + ) -> (exchanged: Bool, original: Int32) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int32" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int32_acquiring(_:_:_:) + public func compareExchange_Int32_acquiring( + _ value: UnsafeAtomic, + _ expected: Int32, + _ desired: Int32 + ) -> (exchanged: Bool, original: Int32) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int32" + // CHECK: builtin "cmpxchg_acquire_acquire_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int32" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int32_releasing(_:_:_:) + public func compareExchange_Int32_releasing( + _ value: UnsafeAtomic, + _ expected: Int32, + _ desired: Int32 + ) -> (exchanged: Bool, original: Int32) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int32" + // CHECK: builtin "cmpxchg_release_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int32" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int32_acquiringAndReleasing(_:_:_:) + public func compareExchange_Int32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ expected: Int32, + _ desired: Int32 + ) -> (exchanged: Bool, original: Int32) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int32" + // CHECK: builtin "cmpxchg_acqrel_acquire_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int32" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int32_sequential(_:_:_:) + public func compareExchange_Int32_sequential( + _ value: UnsafeAtomic, + _ expected: Int32, + _ desired: Int32 + ) -> (exchanged: Bool, original: Int32) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int32" + // CHECK: builtin "cmpxchg_seqcst_seqcst_Int32" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int16_relaxed(_:_:_:) + public func compareExchange_Int16_relaxed( + _ value: UnsafeAtomic, + _ expected: Int16, + _ desired: Int16 + ) -> (exchanged: Bool, original: Int16) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int16" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int16_acquiring(_:_:_:) + public func compareExchange_Int16_acquiring( + _ value: UnsafeAtomic, + _ expected: Int16, + _ desired: Int16 + ) -> (exchanged: Bool, original: Int16) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int16" + // CHECK: builtin "cmpxchg_acquire_acquire_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int16" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int16_releasing(_:_:_:) + public func compareExchange_Int16_releasing( + _ value: UnsafeAtomic, + _ expected: Int16, + _ desired: Int16 + ) -> (exchanged: Bool, original: Int16) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int16" + // CHECK: builtin "cmpxchg_release_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int16" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int16_acquiringAndReleasing(_:_:_:) + public func compareExchange_Int16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ expected: Int16, + _ desired: Int16 + ) -> (exchanged: Bool, original: Int16) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int16" + // CHECK: builtin "cmpxchg_acqrel_acquire_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int16" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int16_sequential(_:_:_:) + public func compareExchange_Int16_sequential( + _ value: UnsafeAtomic, + _ expected: Int16, + _ desired: Int16 + ) -> (exchanged: Bool, original: Int16) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int16" + // CHECK: builtin "cmpxchg_seqcst_seqcst_Int16" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int8_relaxed(_:_:_:) + public func compareExchange_Int8_relaxed( + _ value: UnsafeAtomic, + _ expected: Int8, + _ desired: Int8 + ) -> (exchanged: Bool, original: Int8) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int8" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int8_acquiring(_:_:_:) + public func compareExchange_Int8_acquiring( + _ value: UnsafeAtomic, + _ expected: Int8, + _ desired: Int8 + ) -> (exchanged: Bool, original: Int8) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int8" + // CHECK: builtin "cmpxchg_acquire_acquire_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int8" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int8_releasing(_:_:_:) + public func compareExchange_Int8_releasing( + _ value: UnsafeAtomic, + _ expected: Int8, + _ desired: Int8 + ) -> (exchanged: Bool, original: Int8) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int8" + // CHECK: builtin "cmpxchg_release_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int8" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int8_acquiringAndReleasing(_:_:_:) + public func compareExchange_Int8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ expected: Int8, + _ desired: Int8 + ) -> (exchanged: Bool, original: Int8) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int8" + // CHECK: builtin "cmpxchg_acqrel_acquire_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int8" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Int8_sequential(_:_:_:) + public func compareExchange_Int8_sequential( + _ value: UnsafeAtomic, + _ expected: Int8, + _ desired: Int8 + ) -> (exchanged: Bool, original: Int8) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int8" + // CHECK: builtin "cmpxchg_seqcst_seqcst_Int8" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt_relaxed(_:_:_:) + public func compareExchange_UInt_relaxed( + _ value: UnsafeAtomic, + _ expected: UInt, + _ desired: UInt + ) -> (exchanged: Bool, original: UInt) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt_acquiring(_:_:_:) + public func compareExchange_UInt_acquiring( + _ value: UnsafeAtomic, + _ expected: UInt, + _ desired: UInt + ) -> (exchanged: Bool, original: UInt) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt_releasing(_:_:_:) + public func compareExchange_UInt_releasing( + _ value: UnsafeAtomic, + _ expected: UInt, + _ desired: UInt + ) -> (exchanged: Bool, original: UInt) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_release_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt_acquiringAndReleasing(_:_:_:) + public func compareExchange_UInt_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ expected: UInt, + _ desired: UInt + ) -> (exchanged: Bool, original: UInt) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt_sequential(_:_:_:) + public func compareExchange_UInt_sequential( + _ value: UnsafeAtomic, + _ expected: UInt, + _ desired: UInt + ) -> (exchanged: Bool, original: UInt) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt64_relaxed(_:_:_:) + public func compareExchange_UInt64_relaxed( + _ value: UnsafeAtomic, + _ expected: UInt64, + _ desired: UInt64 + ) -> (exchanged: Bool, original: UInt64) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int64" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt64_acquiring(_:_:_:) + public func compareExchange_UInt64_acquiring( + _ value: UnsafeAtomic, + _ expected: UInt64, + _ desired: UInt64 + ) -> (exchanged: Bool, original: UInt64) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int64" + // CHECK: builtin "cmpxchg_acquire_acquire_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int64" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt64_releasing(_:_:_:) + public func compareExchange_UInt64_releasing( + _ value: UnsafeAtomic, + _ expected: UInt64, + _ desired: UInt64 + ) -> (exchanged: Bool, original: UInt64) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int64" + // CHECK: builtin "cmpxchg_release_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int64" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt64_acquiringAndReleasing(_:_:_:) + public func compareExchange_UInt64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ expected: UInt64, + _ desired: UInt64 + ) -> (exchanged: Bool, original: UInt64) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int64" + // CHECK: builtin "cmpxchg_acqrel_acquire_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int64" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt64_sequential(_:_:_:) + public func compareExchange_UInt64_sequential( + _ value: UnsafeAtomic, + _ expected: UInt64, + _ desired: UInt64 + ) -> (exchanged: Bool, original: UInt64) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int64" + // CHECK: builtin "cmpxchg_seqcst_seqcst_Int64" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt32_relaxed(_:_:_:) + public func compareExchange_UInt32_relaxed( + _ value: UnsafeAtomic, + _ expected: UInt32, + _ desired: UInt32 + ) -> (exchanged: Bool, original: UInt32) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int32" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt32_acquiring(_:_:_:) + public func compareExchange_UInt32_acquiring( + _ value: UnsafeAtomic, + _ expected: UInt32, + _ desired: UInt32 + ) -> (exchanged: Bool, original: UInt32) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int32" + // CHECK: builtin "cmpxchg_acquire_acquire_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int32" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt32_releasing(_:_:_:) + public func compareExchange_UInt32_releasing( + _ value: UnsafeAtomic, + _ expected: UInt32, + _ desired: UInt32 + ) -> (exchanged: Bool, original: UInt32) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int32" + // CHECK: builtin "cmpxchg_release_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int32" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt32_acquiringAndReleasing(_:_:_:) + public func compareExchange_UInt32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ expected: UInt32, + _ desired: UInt32 + ) -> (exchanged: Bool, original: UInt32) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int32" + // CHECK: builtin "cmpxchg_acqrel_acquire_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int32" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt32_sequential(_:_:_:) + public func compareExchange_UInt32_sequential( + _ value: UnsafeAtomic, + _ expected: UInt32, + _ desired: UInt32 + ) -> (exchanged: Bool, original: UInt32) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int32" + // CHECK: builtin "cmpxchg_seqcst_seqcst_Int32" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt16_relaxed(_:_:_:) + public func compareExchange_UInt16_relaxed( + _ value: UnsafeAtomic, + _ expected: UInt16, + _ desired: UInt16 + ) -> (exchanged: Bool, original: UInt16) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int16" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt16_acquiring(_:_:_:) + public func compareExchange_UInt16_acquiring( + _ value: UnsafeAtomic, + _ expected: UInt16, + _ desired: UInt16 + ) -> (exchanged: Bool, original: UInt16) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int16" + // CHECK: builtin "cmpxchg_acquire_acquire_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int16" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt16_releasing(_:_:_:) + public func compareExchange_UInt16_releasing( + _ value: UnsafeAtomic, + _ expected: UInt16, + _ desired: UInt16 + ) -> (exchanged: Bool, original: UInt16) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int16" + // CHECK: builtin "cmpxchg_release_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int16" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt16_acquiringAndReleasing(_:_:_:) + public func compareExchange_UInt16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ expected: UInt16, + _ desired: UInt16 + ) -> (exchanged: Bool, original: UInt16) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int16" + // CHECK: builtin "cmpxchg_acqrel_acquire_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int16" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt16_sequential(_:_:_:) + public func compareExchange_UInt16_sequential( + _ value: UnsafeAtomic, + _ expected: UInt16, + _ desired: UInt16 + ) -> (exchanged: Bool, original: UInt16) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int16" + // CHECK: builtin "cmpxchg_seqcst_seqcst_Int16" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt8_relaxed(_:_:_:) + public func compareExchange_UInt8_relaxed( + _ value: UnsafeAtomic, + _ expected: UInt8, + _ desired: UInt8 + ) -> (exchanged: Bool, original: UInt8) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int8" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt8_acquiring(_:_:_:) + public func compareExchange_UInt8_acquiring( + _ value: UnsafeAtomic, + _ expected: UInt8, + _ desired: UInt8 + ) -> (exchanged: Bool, original: UInt8) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int8" + // CHECK: builtin "cmpxchg_acquire_acquire_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int8" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt8_releasing(_:_:_:) + public func compareExchange_UInt8_releasing( + _ value: UnsafeAtomic, + _ expected: UInt8, + _ desired: UInt8 + ) -> (exchanged: Bool, original: UInt8) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int8" + // CHECK: builtin "cmpxchg_release_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int8" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt8_acquiringAndReleasing(_:_:_:) + public func compareExchange_UInt8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ expected: UInt8, + _ desired: UInt8 + ) -> (exchanged: Bool, original: UInt8) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int8" + // CHECK: builtin "cmpxchg_acqrel_acquire_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int8" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UInt8_sequential(_:_:_:) + public func compareExchange_UInt8_sequential( + _ value: UnsafeAtomic, + _ expected: UInt8, + _ desired: UInt8 + ) -> (exchanged: Bool, original: UInt8) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int8" + // CHECK: builtin "cmpxchg_seqcst_seqcst_Int8" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UnsafeRawPointer_relaxed(_:_:_:) + public func compareExchange_UnsafeRawPointer_relaxed( + _ value: UnsafeAtomic, + _ expected: UnsafeRawPointer, + _ desired: UnsafeRawPointer + ) -> (exchanged: Bool, original: UnsafeRawPointer) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UnsafeRawPointer_acquiring(_:_:_:) + public func compareExchange_UnsafeRawPointer_acquiring( + _ value: UnsafeAtomic, + _ expected: UnsafeRawPointer, + _ desired: UnsafeRawPointer + ) -> (exchanged: Bool, original: UnsafeRawPointer) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UnsafeRawPointer_releasing(_:_:_:) + public func compareExchange_UnsafeRawPointer_releasing( + _ value: UnsafeAtomic, + _ expected: UnsafeRawPointer, + _ desired: UnsafeRawPointer + ) -> (exchanged: Bool, original: UnsafeRawPointer) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_release_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UnsafeRawPointer_acquiringAndReleasing(_:_:_:) + public func compareExchange_UnsafeRawPointer_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ expected: UnsafeRawPointer, + _ desired: UnsafeRawPointer + ) -> (exchanged: Bool, original: UnsafeRawPointer) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UnsafeRawPointer_sequential(_:_:_:) + public func compareExchange_UnsafeRawPointer_sequential( + _ value: UnsafeAtomic, + _ expected: UnsafeRawPointer, + _ desired: UnsafeRawPointer + ) -> (exchanged: Bool, original: UnsafeRawPointer) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UnsafeMutableRawPointer_relaxed(_:_:_:) + public func compareExchange_UnsafeMutableRawPointer_relaxed( + _ value: UnsafeAtomic, + _ expected: UnsafeMutableRawPointer, + _ desired: UnsafeMutableRawPointer + ) -> (exchanged: Bool, original: UnsafeMutableRawPointer) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UnsafeMutableRawPointer_acquiring(_:_:_:) + public func compareExchange_UnsafeMutableRawPointer_acquiring( + _ value: UnsafeAtomic, + _ expected: UnsafeMutableRawPointer, + _ desired: UnsafeMutableRawPointer + ) -> (exchanged: Bool, original: UnsafeMutableRawPointer) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UnsafeMutableRawPointer_releasing(_:_:_:) + public func compareExchange_UnsafeMutableRawPointer_releasing( + _ value: UnsafeAtomic, + _ expected: UnsafeMutableRawPointer, + _ desired: UnsafeMutableRawPointer + ) -> (exchanged: Bool, original: UnsafeMutableRawPointer) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_release_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UnsafeMutableRawPointer_acquiringAndReleasing(_:_:_:) + public func compareExchange_UnsafeMutableRawPointer_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ expected: UnsafeMutableRawPointer, + _ desired: UnsafeMutableRawPointer + ) -> (exchanged: Bool, original: UnsafeMutableRawPointer) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UnsafeMutableRawPointer_sequential(_:_:_:) + public func compareExchange_UnsafeMutableRawPointer_sequential( + _ value: UnsafeAtomic, + _ expected: UnsafeMutableRawPointer, + _ desired: UnsafeMutableRawPointer + ) -> (exchanged: Bool, original: UnsafeMutableRawPointer) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UnsafePointer_relaxed(_:_:_:) + public func compareExchange_UnsafePointer_relaxed( + _ value: UnsafeAtomic>, + _ expected: UnsafePointer, + _ desired: UnsafePointer + ) -> (exchanged: Bool, original: UnsafePointer) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UnsafePointer_acquiring(_:_:_:) + public func compareExchange_UnsafePointer_acquiring( + _ value: UnsafeAtomic>, + _ expected: UnsafePointer, + _ desired: UnsafePointer + ) -> (exchanged: Bool, original: UnsafePointer) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UnsafePointer_releasing(_:_:_:) + public func compareExchange_UnsafePointer_releasing( + _ value: UnsafeAtomic>, + _ expected: UnsafePointer, + _ desired: UnsafePointer + ) -> (exchanged: Bool, original: UnsafePointer) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_release_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UnsafePointer_acquiringAndReleasing(_:_:_:) + public func compareExchange_UnsafePointer_acquiringAndReleasing( + _ value: UnsafeAtomic>, + _ expected: UnsafePointer, + _ desired: UnsafePointer + ) -> (exchanged: Bool, original: UnsafePointer) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UnsafePointer_sequential(_:_:_:) + public func compareExchange_UnsafePointer_sequential( + _ value: UnsafeAtomic>, + _ expected: UnsafePointer, + _ desired: UnsafePointer + ) -> (exchanged: Bool, original: UnsafePointer) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UnsafeMutablePointer_relaxed(_:_:_:) + public func compareExchange_UnsafeMutablePointer_relaxed( + _ value: UnsafeAtomic>, + _ expected: UnsafeMutablePointer, + _ desired: UnsafeMutablePointer + ) -> (exchanged: Bool, original: UnsafeMutablePointer) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UnsafeMutablePointer_acquiring(_:_:_:) + public func compareExchange_UnsafeMutablePointer_acquiring( + _ value: UnsafeAtomic>, + _ expected: UnsafeMutablePointer, + _ desired: UnsafeMutablePointer + ) -> (exchanged: Bool, original: UnsafeMutablePointer) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UnsafeMutablePointer_releasing(_:_:_:) + public func compareExchange_UnsafeMutablePointer_releasing( + _ value: UnsafeAtomic>, + _ expected: UnsafeMutablePointer, + _ desired: UnsafeMutablePointer + ) -> (exchanged: Bool, original: UnsafeMutablePointer) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_release_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UnsafeMutablePointer_acquiringAndReleasing(_:_:_:) + public func compareExchange_UnsafeMutablePointer_acquiringAndReleasing( + _ value: UnsafeAtomic>, + _ expected: UnsafeMutablePointer, + _ desired: UnsafeMutablePointer + ) -> (exchanged: Bool, original: UnsafeMutablePointer) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_UnsafeMutablePointer_sequential(_:_:_:) + public func compareExchange_UnsafeMutablePointer_sequential( + _ value: UnsafeAtomic>, + _ expected: UnsafeMutablePointer, + _ desired: UnsafeMutablePointer + ) -> (exchanged: Bool, original: UnsafeMutablePointer) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Unmanaged_relaxed(_:_:_:) + public func compareExchange_Unmanaged_relaxed( + _ value: UnsafeAtomic>, + _ expected: Unmanaged, + _ desired: Unmanaged + ) -> (exchanged: Bool, original: Unmanaged) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Unmanaged_acquiring(_:_:_:) + public func compareExchange_Unmanaged_acquiring( + _ value: UnsafeAtomic>, + _ expected: Unmanaged, + _ desired: Unmanaged + ) -> (exchanged: Bool, original: Unmanaged) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Unmanaged_releasing(_:_:_:) + public func compareExchange_Unmanaged_releasing( + _ value: UnsafeAtomic>, + _ expected: Unmanaged, + _ desired: Unmanaged + ) -> (exchanged: Bool, original: Unmanaged) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_release_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Unmanaged_acquiringAndReleasing(_:_:_:) + public func compareExchange_Unmanaged_acquiringAndReleasing( + _ value: UnsafeAtomic>, + _ expected: Unmanaged, + _ desired: Unmanaged + ) -> (exchanged: Bool, original: Unmanaged) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_Unmanaged_sequential(_:_:_:) + public func compareExchange_Unmanaged_sequential( + _ value: UnsafeAtomic>, + _ expected: Unmanaged, + _ desired: Unmanaged + ) -> (exchanged: Bool, original: Unmanaged) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnsafeRawPointer_relaxed(_:_:_:) + public func compareExchange_OptionalUnsafeRawPointer_relaxed( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnsafeRawPointer_acquiring(_:_:_:) + public func compareExchange_OptionalUnsafeRawPointer_acquiring( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnsafeRawPointer_releasing(_:_:_:) + public func compareExchange_OptionalUnsafeRawPointer_releasing( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_release_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnsafeRawPointer_acquiringAndReleasing(_:_:_:) + public func compareExchange_OptionalUnsafeRawPointer_acquiringAndReleasing( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnsafeRawPointer_sequential(_:_:_:) + public func compareExchange_OptionalUnsafeRawPointer_sequential( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnsafeMutableRawPointer_relaxed(_:_:_:) + public func compareExchange_OptionalUnsafeMutableRawPointer_relaxed( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnsafeMutableRawPointer_acquiring(_:_:_:) + public func compareExchange_OptionalUnsafeMutableRawPointer_acquiring( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnsafeMutableRawPointer_releasing(_:_:_:) + public func compareExchange_OptionalUnsafeMutableRawPointer_releasing( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_release_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnsafeMutableRawPointer_acquiringAndReleasing(_:_:_:) + public func compareExchange_OptionalUnsafeMutableRawPointer_acquiringAndReleasing( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnsafeMutableRawPointer_sequential(_:_:_:) + public func compareExchange_OptionalUnsafeMutableRawPointer_sequential( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnsafePointer_relaxed(_:_:_:) + public func compareExchange_OptionalUnsafePointer_relaxed( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnsafePointer_acquiring(_:_:_:) + public func compareExchange_OptionalUnsafePointer_acquiring( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnsafePointer_releasing(_:_:_:) + public func compareExchange_OptionalUnsafePointer_releasing( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_release_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnsafePointer_acquiringAndReleasing(_:_:_:) + public func compareExchange_OptionalUnsafePointer_acquiringAndReleasing( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnsafePointer_sequential(_:_:_:) + public func compareExchange_OptionalUnsafePointer_sequential( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnsafeMutablePointer_relaxed(_:_:_:) + public func compareExchange_OptionalUnsafeMutablePointer_relaxed( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnsafeMutablePointer_acquiring(_:_:_:) + public func compareExchange_OptionalUnsafeMutablePointer_acquiring( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnsafeMutablePointer_releasing(_:_:_:) + public func compareExchange_OptionalUnsafeMutablePointer_releasing( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_release_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnsafeMutablePointer_acquiringAndReleasing(_:_:_:) + public func compareExchange_OptionalUnsafeMutablePointer_acquiringAndReleasing( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnsafeMutablePointer_sequential(_:_:_:) + public func compareExchange_OptionalUnsafeMutablePointer_sequential( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnmanaged_relaxed(_:_:_:) + public func compareExchange_OptionalUnmanaged_relaxed( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnmanaged_acquiring(_:_:_:) + public func compareExchange_OptionalUnmanaged_acquiring( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnmanaged_releasing(_:_:_:) + public func compareExchange_OptionalUnmanaged_releasing( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_release_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnmanaged_acquiringAndReleasing(_:_:_:) + public func compareExchange_OptionalUnmanaged_acquiringAndReleasing( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange_OptionalUnmanaged_sequential(_:_:_:) + public func compareExchange_OptionalUnmanaged_sequential( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + return value.compareExchange( + expected: expected, + desired: desired, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // --------------------------------------------------------------------------- + // FIXME: There are 15 valid combinations of success/failure orderings; + // here we're only testing 6 of them. + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int_relaxed_relaxed(_:_:_:) + public func compareExchange2_Int_relaxed_relaxed( + _ value: UnsafeAtomic, + _ expected: Int, + _ desired: Int + ) -> (exchanged: Bool, original: Int) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int_acquiring_relaxed(_:_:_:) + public func compareExchange2_Int_acquiring_relaxed( + _ value: UnsafeAtomic, + _ expected: Int, + _ desired: Int + ) -> (exchanged: Bool, original: Int) { + // CHECK: builtin "cmpxchg_acquire_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int_acquiring_acquiring(_:_:_:) + public func compareExchange2_Int_acquiring_acquiring( + _ value: UnsafeAtomic, + _ expected: Int, + _ desired: Int + ) -> (exchanged: Bool, original: Int) { + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int_sequential_acquiring(_:_:_:) + public func compareExchange2_Int_sequential_acquiring( + _ value: UnsafeAtomic, + _ expected: Int, + _ desired: Int + ) -> (exchanged: Bool, original: Int) { + // CHECK: builtin "cmpxchg_seqcst_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int_releasing_acquiring(_:_:_:) + public func compareExchange2_Int_releasing_acquiring( + _ value: UnsafeAtomic, + _ expected: Int, + _ desired: Int + ) -> (exchanged: Bool, original: Int) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int_relaxed_sequential(_:_:_:) + public func compareExchange2_Int_relaxed_sequential( + _ value: UnsafeAtomic, + _ expected: Int, + _ desired: Int + ) -> (exchanged: Bool, original: Int) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int64_relaxed_relaxed(_:_:_:) + public func compareExchange2_Int64_relaxed_relaxed( + _ value: UnsafeAtomic, + _ expected: Int64, + _ desired: Int64 + ) -> (exchanged: Bool, original: Int64) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int64" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int64_acquiring_relaxed(_:_:_:) + public func compareExchange2_Int64_acquiring_relaxed( + _ value: UnsafeAtomic, + _ expected: Int64, + _ desired: Int64 + ) -> (exchanged: Bool, original: Int64) { + // CHECK: builtin "cmpxchg_acquire_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int64" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int64_acquiring_acquiring(_:_:_:) + public func compareExchange2_Int64_acquiring_acquiring( + _ value: UnsafeAtomic, + _ expected: Int64, + _ desired: Int64 + ) -> (exchanged: Bool, original: Int64) { + // CHECK: builtin "cmpxchg_acquire_acquire_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int64" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int64_sequential_acquiring(_:_:_:) + public func compareExchange2_Int64_sequential_acquiring( + _ value: UnsafeAtomic, + _ expected: Int64, + _ desired: Int64 + ) -> (exchanged: Bool, original: Int64) { + // CHECK: builtin "cmpxchg_seqcst_acquire_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_Int64" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int64_releasing_acquiring(_:_:_:) + public func compareExchange2_Int64_releasing_acquiring( + _ value: UnsafeAtomic, + _ expected: Int64, + _ desired: Int64 + ) -> (exchanged: Bool, original: Int64) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int64" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int64_relaxed_sequential(_:_:_:) + public func compareExchange2_Int64_relaxed_sequential( + _ value: UnsafeAtomic, + _ expected: Int64, + _ desired: Int64 + ) -> (exchanged: Bool, original: Int64) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_Int64" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int32_relaxed_relaxed(_:_:_:) + public func compareExchange2_Int32_relaxed_relaxed( + _ value: UnsafeAtomic, + _ expected: Int32, + _ desired: Int32 + ) -> (exchanged: Bool, original: Int32) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int32" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int32_acquiring_relaxed(_:_:_:) + public func compareExchange2_Int32_acquiring_relaxed( + _ value: UnsafeAtomic, + _ expected: Int32, + _ desired: Int32 + ) -> (exchanged: Bool, original: Int32) { + // CHECK: builtin "cmpxchg_acquire_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int32" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int32_acquiring_acquiring(_:_:_:) + public func compareExchange2_Int32_acquiring_acquiring( + _ value: UnsafeAtomic, + _ expected: Int32, + _ desired: Int32 + ) -> (exchanged: Bool, original: Int32) { + // CHECK: builtin "cmpxchg_acquire_acquire_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int32" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int32_sequential_acquiring(_:_:_:) + public func compareExchange2_Int32_sequential_acquiring( + _ value: UnsafeAtomic, + _ expected: Int32, + _ desired: Int32 + ) -> (exchanged: Bool, original: Int32) { + // CHECK: builtin "cmpxchg_seqcst_acquire_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_Int32" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int32_releasing_acquiring(_:_:_:) + public func compareExchange2_Int32_releasing_acquiring( + _ value: UnsafeAtomic, + _ expected: Int32, + _ desired: Int32 + ) -> (exchanged: Bool, original: Int32) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int32" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int32_relaxed_sequential(_:_:_:) + public func compareExchange2_Int32_relaxed_sequential( + _ value: UnsafeAtomic, + _ expected: Int32, + _ desired: Int32 + ) -> (exchanged: Bool, original: Int32) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_Int32" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int16_relaxed_relaxed(_:_:_:) + public func compareExchange2_Int16_relaxed_relaxed( + _ value: UnsafeAtomic, + _ expected: Int16, + _ desired: Int16 + ) -> (exchanged: Bool, original: Int16) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int16" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int16_acquiring_relaxed(_:_:_:) + public func compareExchange2_Int16_acquiring_relaxed( + _ value: UnsafeAtomic, + _ expected: Int16, + _ desired: Int16 + ) -> (exchanged: Bool, original: Int16) { + // CHECK: builtin "cmpxchg_acquire_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int16" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int16_acquiring_acquiring(_:_:_:) + public func compareExchange2_Int16_acquiring_acquiring( + _ value: UnsafeAtomic, + _ expected: Int16, + _ desired: Int16 + ) -> (exchanged: Bool, original: Int16) { + // CHECK: builtin "cmpxchg_acquire_acquire_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int16" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int16_sequential_acquiring(_:_:_:) + public func compareExchange2_Int16_sequential_acquiring( + _ value: UnsafeAtomic, + _ expected: Int16, + _ desired: Int16 + ) -> (exchanged: Bool, original: Int16) { + // CHECK: builtin "cmpxchg_seqcst_acquire_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_Int16" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int16_releasing_acquiring(_:_:_:) + public func compareExchange2_Int16_releasing_acquiring( + _ value: UnsafeAtomic, + _ expected: Int16, + _ desired: Int16 + ) -> (exchanged: Bool, original: Int16) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int16" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int16_relaxed_sequential(_:_:_:) + public func compareExchange2_Int16_relaxed_sequential( + _ value: UnsafeAtomic, + _ expected: Int16, + _ desired: Int16 + ) -> (exchanged: Bool, original: Int16) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_Int16" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int8_relaxed_relaxed(_:_:_:) + public func compareExchange2_Int8_relaxed_relaxed( + _ value: UnsafeAtomic, + _ expected: Int8, + _ desired: Int8 + ) -> (exchanged: Bool, original: Int8) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int8" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int8_acquiring_relaxed(_:_:_:) + public func compareExchange2_Int8_acquiring_relaxed( + _ value: UnsafeAtomic, + _ expected: Int8, + _ desired: Int8 + ) -> (exchanged: Bool, original: Int8) { + // CHECK: builtin "cmpxchg_acquire_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int8" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int8_acquiring_acquiring(_:_:_:) + public func compareExchange2_Int8_acquiring_acquiring( + _ value: UnsafeAtomic, + _ expected: Int8, + _ desired: Int8 + ) -> (exchanged: Bool, original: Int8) { + // CHECK: builtin "cmpxchg_acquire_acquire_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int8" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int8_sequential_acquiring(_:_:_:) + public func compareExchange2_Int8_sequential_acquiring( + _ value: UnsafeAtomic, + _ expected: Int8, + _ desired: Int8 + ) -> (exchanged: Bool, original: Int8) { + // CHECK: builtin "cmpxchg_seqcst_acquire_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_Int8" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int8_releasing_acquiring(_:_:_:) + public func compareExchange2_Int8_releasing_acquiring( + _ value: UnsafeAtomic, + _ expected: Int8, + _ desired: Int8 + ) -> (exchanged: Bool, original: Int8) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int8" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int8_relaxed_sequential(_:_:_:) + public func compareExchange2_Int8_relaxed_sequential( + _ value: UnsafeAtomic, + _ expected: Int8, + _ desired: Int8 + ) -> (exchanged: Bool, original: Int8) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_Int8" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt_relaxed_relaxed(_:_:_:) + public func compareExchange2_UInt_relaxed_relaxed( + _ value: UnsafeAtomic, + _ expected: UInt, + _ desired: UInt + ) -> (exchanged: Bool, original: UInt) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt_acquiring_relaxed(_:_:_:) + public func compareExchange2_UInt_acquiring_relaxed( + _ value: UnsafeAtomic, + _ expected: UInt, + _ desired: UInt + ) -> (exchanged: Bool, original: UInt) { + // CHECK: builtin "cmpxchg_acquire_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt_acquiring_acquiring(_:_:_:) + public func compareExchange2_UInt_acquiring_acquiring( + _ value: UnsafeAtomic, + _ expected: UInt, + _ desired: UInt + ) -> (exchanged: Bool, original: UInt) { + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt_sequential_acquiring(_:_:_:) + public func compareExchange2_UInt_sequential_acquiring( + _ value: UnsafeAtomic, + _ expected: UInt, + _ desired: UInt + ) -> (exchanged: Bool, original: UInt) { + // CHECK: builtin "cmpxchg_seqcst_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt_releasing_acquiring(_:_:_:) + public func compareExchange2_UInt_releasing_acquiring( + _ value: UnsafeAtomic, + _ expected: UInt, + _ desired: UInt + ) -> (exchanged: Bool, original: UInt) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt_relaxed_sequential(_:_:_:) + public func compareExchange2_UInt_relaxed_sequential( + _ value: UnsafeAtomic, + _ expected: UInt, + _ desired: UInt + ) -> (exchanged: Bool, original: UInt) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt64_relaxed_relaxed(_:_:_:) + public func compareExchange2_UInt64_relaxed_relaxed( + _ value: UnsafeAtomic, + _ expected: UInt64, + _ desired: UInt64 + ) -> (exchanged: Bool, original: UInt64) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int64" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt64_acquiring_relaxed(_:_:_:) + public func compareExchange2_UInt64_acquiring_relaxed( + _ value: UnsafeAtomic, + _ expected: UInt64, + _ desired: UInt64 + ) -> (exchanged: Bool, original: UInt64) { + // CHECK: builtin "cmpxchg_acquire_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int64" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt64_acquiring_acquiring(_:_:_:) + public func compareExchange2_UInt64_acquiring_acquiring( + _ value: UnsafeAtomic, + _ expected: UInt64, + _ desired: UInt64 + ) -> (exchanged: Bool, original: UInt64) { + // CHECK: builtin "cmpxchg_acquire_acquire_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int64" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt64_sequential_acquiring(_:_:_:) + public func compareExchange2_UInt64_sequential_acquiring( + _ value: UnsafeAtomic, + _ expected: UInt64, + _ desired: UInt64 + ) -> (exchanged: Bool, original: UInt64) { + // CHECK: builtin "cmpxchg_seqcst_acquire_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_Int64" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt64_releasing_acquiring(_:_:_:) + public func compareExchange2_UInt64_releasing_acquiring( + _ value: UnsafeAtomic, + _ expected: UInt64, + _ desired: UInt64 + ) -> (exchanged: Bool, original: UInt64) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int64" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt64_relaxed_sequential(_:_:_:) + public func compareExchange2_UInt64_relaxed_sequential( + _ value: UnsafeAtomic, + _ expected: UInt64, + _ desired: UInt64 + ) -> (exchanged: Bool, original: UInt64) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_Int64" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt32_relaxed_relaxed(_:_:_:) + public func compareExchange2_UInt32_relaxed_relaxed( + _ value: UnsafeAtomic, + _ expected: UInt32, + _ desired: UInt32 + ) -> (exchanged: Bool, original: UInt32) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int32" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt32_acquiring_relaxed(_:_:_:) + public func compareExchange2_UInt32_acquiring_relaxed( + _ value: UnsafeAtomic, + _ expected: UInt32, + _ desired: UInt32 + ) -> (exchanged: Bool, original: UInt32) { + // CHECK: builtin "cmpxchg_acquire_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int32" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt32_acquiring_acquiring(_:_:_:) + public func compareExchange2_UInt32_acquiring_acquiring( + _ value: UnsafeAtomic, + _ expected: UInt32, + _ desired: UInt32 + ) -> (exchanged: Bool, original: UInt32) { + // CHECK: builtin "cmpxchg_acquire_acquire_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int32" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt32_sequential_acquiring(_:_:_:) + public func compareExchange2_UInt32_sequential_acquiring( + _ value: UnsafeAtomic, + _ expected: UInt32, + _ desired: UInt32 + ) -> (exchanged: Bool, original: UInt32) { + // CHECK: builtin "cmpxchg_seqcst_acquire_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_Int32" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt32_releasing_acquiring(_:_:_:) + public func compareExchange2_UInt32_releasing_acquiring( + _ value: UnsafeAtomic, + _ expected: UInt32, + _ desired: UInt32 + ) -> (exchanged: Bool, original: UInt32) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int32" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt32_relaxed_sequential(_:_:_:) + public func compareExchange2_UInt32_relaxed_sequential( + _ value: UnsafeAtomic, + _ expected: UInt32, + _ desired: UInt32 + ) -> (exchanged: Bool, original: UInt32) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_Int32" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt16_relaxed_relaxed(_:_:_:) + public func compareExchange2_UInt16_relaxed_relaxed( + _ value: UnsafeAtomic, + _ expected: UInt16, + _ desired: UInt16 + ) -> (exchanged: Bool, original: UInt16) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int16" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt16_acquiring_relaxed(_:_:_:) + public func compareExchange2_UInt16_acquiring_relaxed( + _ value: UnsafeAtomic, + _ expected: UInt16, + _ desired: UInt16 + ) -> (exchanged: Bool, original: UInt16) { + // CHECK: builtin "cmpxchg_acquire_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int16" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt16_acquiring_acquiring(_:_:_:) + public func compareExchange2_UInt16_acquiring_acquiring( + _ value: UnsafeAtomic, + _ expected: UInt16, + _ desired: UInt16 + ) -> (exchanged: Bool, original: UInt16) { + // CHECK: builtin "cmpxchg_acquire_acquire_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int16" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt16_sequential_acquiring(_:_:_:) + public func compareExchange2_UInt16_sequential_acquiring( + _ value: UnsafeAtomic, + _ expected: UInt16, + _ desired: UInt16 + ) -> (exchanged: Bool, original: UInt16) { + // CHECK: builtin "cmpxchg_seqcst_acquire_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_Int16" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt16_releasing_acquiring(_:_:_:) + public func compareExchange2_UInt16_releasing_acquiring( + _ value: UnsafeAtomic, + _ expected: UInt16, + _ desired: UInt16 + ) -> (exchanged: Bool, original: UInt16) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int16" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt16_relaxed_sequential(_:_:_:) + public func compareExchange2_UInt16_relaxed_sequential( + _ value: UnsafeAtomic, + _ expected: UInt16, + _ desired: UInt16 + ) -> (exchanged: Bool, original: UInt16) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_Int16" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt8_relaxed_relaxed(_:_:_:) + public func compareExchange2_UInt8_relaxed_relaxed( + _ value: UnsafeAtomic, + _ expected: UInt8, + _ desired: UInt8 + ) -> (exchanged: Bool, original: UInt8) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int8" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt8_acquiring_relaxed(_:_:_:) + public func compareExchange2_UInt8_acquiring_relaxed( + _ value: UnsafeAtomic, + _ expected: UInt8, + _ desired: UInt8 + ) -> (exchanged: Bool, original: UInt8) { + // CHECK: builtin "cmpxchg_acquire_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int8" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt8_acquiring_acquiring(_:_:_:) + public func compareExchange2_UInt8_acquiring_acquiring( + _ value: UnsafeAtomic, + _ expected: UInt8, + _ desired: UInt8 + ) -> (exchanged: Bool, original: UInt8) { + // CHECK: builtin "cmpxchg_acquire_acquire_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int8" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt8_sequential_acquiring(_:_:_:) + public func compareExchange2_UInt8_sequential_acquiring( + _ value: UnsafeAtomic, + _ expected: UInt8, + _ desired: UInt8 + ) -> (exchanged: Bool, original: UInt8) { + // CHECK: builtin "cmpxchg_seqcst_acquire_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_Int8" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt8_releasing_acquiring(_:_:_:) + public func compareExchange2_UInt8_releasing_acquiring( + _ value: UnsafeAtomic, + _ expected: UInt8, + _ desired: UInt8 + ) -> (exchanged: Bool, original: UInt8) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Int8" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt8_relaxed_sequential(_:_:_:) + public func compareExchange2_UInt8_relaxed_sequential( + _ value: UnsafeAtomic, + _ expected: UInt8, + _ desired: UInt8 + ) -> (exchanged: Bool, original: UInt8) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_Int8" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeRawPointer_relaxed_relaxed(_:_:_:) + public func compareExchange2_UnsafeRawPointer_relaxed_relaxed( + _ value: UnsafeAtomic, + _ expected: UnsafeRawPointer, + _ desired: UnsafeRawPointer + ) -> (exchanged: Bool, original: UnsafeRawPointer) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeRawPointer_acquiring_relaxed(_:_:_:) + public func compareExchange2_UnsafeRawPointer_acquiring_relaxed( + _ value: UnsafeAtomic, + _ expected: UnsafeRawPointer, + _ desired: UnsafeRawPointer + ) -> (exchanged: Bool, original: UnsafeRawPointer) { + // CHECK: builtin "cmpxchg_acquire_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeRawPointer_acquiring_acquiring(_:_:_:) + public func compareExchange2_UnsafeRawPointer_acquiring_acquiring( + _ value: UnsafeAtomic, + _ expected: UnsafeRawPointer, + _ desired: UnsafeRawPointer + ) -> (exchanged: Bool, original: UnsafeRawPointer) { + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeRawPointer_sequential_acquiring(_:_:_:) + public func compareExchange2_UnsafeRawPointer_sequential_acquiring( + _ value: UnsafeAtomic, + _ expected: UnsafeRawPointer, + _ desired: UnsafeRawPointer + ) -> (exchanged: Bool, original: UnsafeRawPointer) { + // CHECK: builtin "cmpxchg_seqcst_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeRawPointer_releasing_acquiring(_:_:_:) + public func compareExchange2_UnsafeRawPointer_releasing_acquiring( + _ value: UnsafeAtomic, + _ expected: UnsafeRawPointer, + _ desired: UnsafeRawPointer + ) -> (exchanged: Bool, original: UnsafeRawPointer) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeRawPointer_relaxed_sequential(_:_:_:) + public func compareExchange2_UnsafeRawPointer_relaxed_sequential( + _ value: UnsafeAtomic, + _ expected: UnsafeRawPointer, + _ desired: UnsafeRawPointer + ) -> (exchanged: Bool, original: UnsafeRawPointer) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutableRawPointer_relaxed_relaxed(_:_:_:) + public func compareExchange2_UnsafeMutableRawPointer_relaxed_relaxed( + _ value: UnsafeAtomic, + _ expected: UnsafeMutableRawPointer, + _ desired: UnsafeMutableRawPointer + ) -> (exchanged: Bool, original: UnsafeMutableRawPointer) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutableRawPointer_acquiring_relaxed(_:_:_:) + public func compareExchange2_UnsafeMutableRawPointer_acquiring_relaxed( + _ value: UnsafeAtomic, + _ expected: UnsafeMutableRawPointer, + _ desired: UnsafeMutableRawPointer + ) -> (exchanged: Bool, original: UnsafeMutableRawPointer) { + // CHECK: builtin "cmpxchg_acquire_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutableRawPointer_acquiring_acquiring(_:_:_:) + public func compareExchange2_UnsafeMutableRawPointer_acquiring_acquiring( + _ value: UnsafeAtomic, + _ expected: UnsafeMutableRawPointer, + _ desired: UnsafeMutableRawPointer + ) -> (exchanged: Bool, original: UnsafeMutableRawPointer) { + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutableRawPointer_sequential_acquiring(_:_:_:) + public func compareExchange2_UnsafeMutableRawPointer_sequential_acquiring( + _ value: UnsafeAtomic, + _ expected: UnsafeMutableRawPointer, + _ desired: UnsafeMutableRawPointer + ) -> (exchanged: Bool, original: UnsafeMutableRawPointer) { + // CHECK: builtin "cmpxchg_seqcst_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutableRawPointer_releasing_acquiring(_:_:_:) + public func compareExchange2_UnsafeMutableRawPointer_releasing_acquiring( + _ value: UnsafeAtomic, + _ expected: UnsafeMutableRawPointer, + _ desired: UnsafeMutableRawPointer + ) -> (exchanged: Bool, original: UnsafeMutableRawPointer) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutableRawPointer_relaxed_sequential(_:_:_:) + public func compareExchange2_UnsafeMutableRawPointer_relaxed_sequential( + _ value: UnsafeAtomic, + _ expected: UnsafeMutableRawPointer, + _ desired: UnsafeMutableRawPointer + ) -> (exchanged: Bool, original: UnsafeMutableRawPointer) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafePointer_relaxed_relaxed(_:_:_:) + public func compareExchange2_UnsafePointer_relaxed_relaxed( + _ value: UnsafeAtomic>, + _ expected: UnsafePointer, + _ desired: UnsafePointer + ) -> (exchanged: Bool, original: UnsafePointer) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafePointer_acquiring_relaxed(_:_:_:) + public func compareExchange2_UnsafePointer_acquiring_relaxed( + _ value: UnsafeAtomic>, + _ expected: UnsafePointer, + _ desired: UnsafePointer + ) -> (exchanged: Bool, original: UnsafePointer) { + // CHECK: builtin "cmpxchg_acquire_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafePointer_acquiring_acquiring(_:_:_:) + public func compareExchange2_UnsafePointer_acquiring_acquiring( + _ value: UnsafeAtomic>, + _ expected: UnsafePointer, + _ desired: UnsafePointer + ) -> (exchanged: Bool, original: UnsafePointer) { + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafePointer_sequential_acquiring(_:_:_:) + public func compareExchange2_UnsafePointer_sequential_acquiring( + _ value: UnsafeAtomic>, + _ expected: UnsafePointer, + _ desired: UnsafePointer + ) -> (exchanged: Bool, original: UnsafePointer) { + // CHECK: builtin "cmpxchg_seqcst_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafePointer_releasing_acquiring(_:_:_:) + public func compareExchange2_UnsafePointer_releasing_acquiring( + _ value: UnsafeAtomic>, + _ expected: UnsafePointer, + _ desired: UnsafePointer + ) -> (exchanged: Bool, original: UnsafePointer) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafePointer_relaxed_sequential(_:_:_:) + public func compareExchange2_UnsafePointer_relaxed_sequential( + _ value: UnsafeAtomic>, + _ expected: UnsafePointer, + _ desired: UnsafePointer + ) -> (exchanged: Bool, original: UnsafePointer) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutablePointer_relaxed_relaxed(_:_:_:) + public func compareExchange2_UnsafeMutablePointer_relaxed_relaxed( + _ value: UnsafeAtomic>, + _ expected: UnsafeMutablePointer, + _ desired: UnsafeMutablePointer + ) -> (exchanged: Bool, original: UnsafeMutablePointer) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutablePointer_acquiring_relaxed(_:_:_:) + public func compareExchange2_UnsafeMutablePointer_acquiring_relaxed( + _ value: UnsafeAtomic>, + _ expected: UnsafeMutablePointer, + _ desired: UnsafeMutablePointer + ) -> (exchanged: Bool, original: UnsafeMutablePointer) { + // CHECK: builtin "cmpxchg_acquire_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutablePointer_acquiring_acquiring(_:_:_:) + public func compareExchange2_UnsafeMutablePointer_acquiring_acquiring( + _ value: UnsafeAtomic>, + _ expected: UnsafeMutablePointer, + _ desired: UnsafeMutablePointer + ) -> (exchanged: Bool, original: UnsafeMutablePointer) { + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutablePointer_sequential_acquiring(_:_:_:) + public func compareExchange2_UnsafeMutablePointer_sequential_acquiring( + _ value: UnsafeAtomic>, + _ expected: UnsafeMutablePointer, + _ desired: UnsafeMutablePointer + ) -> (exchanged: Bool, original: UnsafeMutablePointer) { + // CHECK: builtin "cmpxchg_seqcst_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutablePointer_releasing_acquiring(_:_:_:) + public func compareExchange2_UnsafeMutablePointer_releasing_acquiring( + _ value: UnsafeAtomic>, + _ expected: UnsafeMutablePointer, + _ desired: UnsafeMutablePointer + ) -> (exchanged: Bool, original: UnsafeMutablePointer) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutablePointer_relaxed_sequential(_:_:_:) + public func compareExchange2_UnsafeMutablePointer_relaxed_sequential( + _ value: UnsafeAtomic>, + _ expected: UnsafeMutablePointer, + _ desired: UnsafeMutablePointer + ) -> (exchanged: Bool, original: UnsafeMutablePointer) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Unmanaged_relaxed_relaxed(_:_:_:) + public func compareExchange2_Unmanaged_relaxed_relaxed( + _ value: UnsafeAtomic>, + _ expected: Unmanaged, + _ desired: Unmanaged + ) -> (exchanged: Bool, original: Unmanaged) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Unmanaged_acquiring_relaxed(_:_:_:) + public func compareExchange2_Unmanaged_acquiring_relaxed( + _ value: UnsafeAtomic>, + _ expected: Unmanaged, + _ desired: Unmanaged + ) -> (exchanged: Bool, original: Unmanaged) { + // CHECK: builtin "cmpxchg_acquire_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Unmanaged_acquiring_acquiring(_:_:_:) + public func compareExchange2_Unmanaged_acquiring_acquiring( + _ value: UnsafeAtomic>, + _ expected: Unmanaged, + _ desired: Unmanaged + ) -> (exchanged: Bool, original: Unmanaged) { + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Unmanaged_sequential_acquiring(_:_:_:) + public func compareExchange2_Unmanaged_sequential_acquiring( + _ value: UnsafeAtomic>, + _ expected: Unmanaged, + _ desired: Unmanaged + ) -> (exchanged: Bool, original: Unmanaged) { + // CHECK: builtin "cmpxchg_seqcst_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Unmanaged_releasing_acquiring(_:_:_:) + public func compareExchange2_Unmanaged_releasing_acquiring( + _ value: UnsafeAtomic>, + _ expected: Unmanaged, + _ desired: Unmanaged + ) -> (exchanged: Bool, original: Unmanaged) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Unmanaged_relaxed_sequential(_:_:_:) + public func compareExchange2_Unmanaged_relaxed_sequential( + _ value: UnsafeAtomic>, + _ expected: Unmanaged, + _ desired: Unmanaged + ) -> (exchanged: Bool, original: Unmanaged) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeRawPointer_relaxed_relaxed(_:_:_:) + public func compareExchange2_OptionalUnsafeRawPointer_relaxed_relaxed( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeRawPointer_acquiring_relaxed(_:_:_:) + public func compareExchange2_OptionalUnsafeRawPointer_acquiring_relaxed( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // CHECK: builtin "cmpxchg_acquire_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeRawPointer_acquiring_acquiring(_:_:_:) + public func compareExchange2_OptionalUnsafeRawPointer_acquiring_acquiring( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeRawPointer_sequential_acquiring(_:_:_:) + public func compareExchange2_OptionalUnsafeRawPointer_sequential_acquiring( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // CHECK: builtin "cmpxchg_seqcst_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeRawPointer_releasing_acquiring(_:_:_:) + public func compareExchange2_OptionalUnsafeRawPointer_releasing_acquiring( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeRawPointer_relaxed_sequential(_:_:_:) + public func compareExchange2_OptionalUnsafeRawPointer_relaxed_sequential( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutableRawPointer_relaxed_relaxed(_:_:_:) + public func compareExchange2_OptionalUnsafeMutableRawPointer_relaxed_relaxed( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutableRawPointer_acquiring_relaxed(_:_:_:) + public func compareExchange2_OptionalUnsafeMutableRawPointer_acquiring_relaxed( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // CHECK: builtin "cmpxchg_acquire_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutableRawPointer_acquiring_acquiring(_:_:_:) + public func compareExchange2_OptionalUnsafeMutableRawPointer_acquiring_acquiring( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutableRawPointer_sequential_acquiring(_:_:_:) + public func compareExchange2_OptionalUnsafeMutableRawPointer_sequential_acquiring( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // CHECK: builtin "cmpxchg_seqcst_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutableRawPointer_releasing_acquiring(_:_:_:) + public func compareExchange2_OptionalUnsafeMutableRawPointer_releasing_acquiring( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutableRawPointer_relaxed_sequential(_:_:_:) + public func compareExchange2_OptionalUnsafeMutableRawPointer_relaxed_sequential( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafePointer_relaxed_relaxed(_:_:_:) + public func compareExchange2_OptionalUnsafePointer_relaxed_relaxed( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafePointer_acquiring_relaxed(_:_:_:) + public func compareExchange2_OptionalUnsafePointer_acquiring_relaxed( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_acquire_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafePointer_acquiring_acquiring(_:_:_:) + public func compareExchange2_OptionalUnsafePointer_acquiring_acquiring( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafePointer_sequential_acquiring(_:_:_:) + public func compareExchange2_OptionalUnsafePointer_sequential_acquiring( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_seqcst_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafePointer_releasing_acquiring(_:_:_:) + public func compareExchange2_OptionalUnsafePointer_releasing_acquiring( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafePointer_relaxed_sequential(_:_:_:) + public func compareExchange2_OptionalUnsafePointer_relaxed_sequential( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutablePointer_relaxed_relaxed(_:_:_:) + public func compareExchange2_OptionalUnsafeMutablePointer_relaxed_relaxed( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutablePointer_acquiring_relaxed(_:_:_:) + public func compareExchange2_OptionalUnsafeMutablePointer_acquiring_relaxed( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_acquire_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutablePointer_acquiring_acquiring(_:_:_:) + public func compareExchange2_OptionalUnsafeMutablePointer_acquiring_acquiring( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutablePointer_sequential_acquiring(_:_:_:) + public func compareExchange2_OptionalUnsafeMutablePointer_sequential_acquiring( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_seqcst_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutablePointer_releasing_acquiring(_:_:_:) + public func compareExchange2_OptionalUnsafeMutablePointer_releasing_acquiring( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutablePointer_relaxed_sequential(_:_:_:) + public func compareExchange2_OptionalUnsafeMutablePointer_relaxed_sequential( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnmanaged_relaxed_relaxed(_:_:_:) + public func compareExchange2_OptionalUnmanaged_relaxed_relaxed( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnmanaged_acquiring_relaxed(_:_:_:) + public func compareExchange2_OptionalUnmanaged_acquiring_relaxed( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_acquire_monotonic_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnmanaged_acquiring_acquiring(_:_:_:) + public func compareExchange2_OptionalUnmanaged_acquiring_acquiring( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_acquire_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnmanaged_sequential_acquiring(_:_:_:) + public func compareExchange2_OptionalUnmanaged_sequential_acquiring( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_seqcst_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnmanaged_releasing_acquiring(_:_:_:) + public func compareExchange2_OptionalUnmanaged_releasing_acquiring( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnmanaged_relaxed_sequential(_:_:_:) + public func compareExchange2_OptionalUnmanaged_relaxed_sequential( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_Word" + return value.compareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // --------------------------------------------------------------------------- + // FIXME: There are 15 valid combinations of success/failure orderings; + // here we're only testing 6 of them. + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int_relaxed_relaxed_weak(_:_:_:) + public func compareExchange2_Int_relaxed_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: Int, + _ desired: Int + ) -> (exchanged: Bool, original: Int) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int_acquiring_relaxed_weak(_:_:_:) + public func compareExchange2_Int_acquiring_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: Int, + _ desired: Int + ) -> (exchanged: Bool, original: Int) { + // CHECK: builtin "cmpxchg_acquire_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int_acquiring_acquiring_weak(_:_:_:) + public func compareExchange2_Int_acquiring_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: Int, + _ desired: Int + ) -> (exchanged: Bool, original: Int) { + // CHECK: builtin "cmpxchg_acquire_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int_sequential_acquiring_weak(_:_:_:) + public func compareExchange2_Int_sequential_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: Int, + _ desired: Int + ) -> (exchanged: Bool, original: Int) { + // CHECK: builtin "cmpxchg_seqcst_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int_releasing_acquiring_weak(_:_:_:) + public func compareExchange2_Int_releasing_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: Int, + _ desired: Int + ) -> (exchanged: Bool, original: Int) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int_relaxed_sequential_weak(_:_:_:) + public func compareExchange2_Int_relaxed_sequential_weak( + _ value: UnsafeAtomic, + _ expected: Int, + _ desired: Int + ) -> (exchanged: Bool, original: Int) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int64_relaxed_relaxed_weak(_:_:_:) + public func compareExchange2_Int64_relaxed_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: Int64, + _ desired: Int64 + ) -> (exchanged: Bool, original: Int64) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int64" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int64_acquiring_relaxed_weak(_:_:_:) + public func compareExchange2_Int64_acquiring_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: Int64, + _ desired: Int64 + ) -> (exchanged: Bool, original: Int64) { + // CHECK: builtin "cmpxchg_acquire_monotonic_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int64" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int64_acquiring_acquiring_weak(_:_:_:) + public func compareExchange2_Int64_acquiring_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: Int64, + _ desired: Int64 + ) -> (exchanged: Bool, original: Int64) { + // CHECK: builtin "cmpxchg_acquire_acquire_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int64" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int64_sequential_acquiring_weak(_:_:_:) + public func compareExchange2_Int64_sequential_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: Int64, + _ desired: Int64 + ) -> (exchanged: Bool, original: Int64) { + // CHECK: builtin "cmpxchg_seqcst_acquire_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_weak_Int64" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int64_releasing_acquiring_weak(_:_:_:) + public func compareExchange2_Int64_releasing_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: Int64, + _ desired: Int64 + ) -> (exchanged: Bool, original: Int64) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int64" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int64_relaxed_sequential_weak(_:_:_:) + public func compareExchange2_Int64_relaxed_sequential_weak( + _ value: UnsafeAtomic, + _ expected: Int64, + _ desired: Int64 + ) -> (exchanged: Bool, original: Int64) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_weak_Int64" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int32_relaxed_relaxed_weak(_:_:_:) + public func compareExchange2_Int32_relaxed_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: Int32, + _ desired: Int32 + ) -> (exchanged: Bool, original: Int32) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int32" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int32_acquiring_relaxed_weak(_:_:_:) + public func compareExchange2_Int32_acquiring_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: Int32, + _ desired: Int32 + ) -> (exchanged: Bool, original: Int32) { + // CHECK: builtin "cmpxchg_acquire_monotonic_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int32" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int32_acquiring_acquiring_weak(_:_:_:) + public func compareExchange2_Int32_acquiring_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: Int32, + _ desired: Int32 + ) -> (exchanged: Bool, original: Int32) { + // CHECK: builtin "cmpxchg_acquire_acquire_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int32" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int32_sequential_acquiring_weak(_:_:_:) + public func compareExchange2_Int32_sequential_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: Int32, + _ desired: Int32 + ) -> (exchanged: Bool, original: Int32) { + // CHECK: builtin "cmpxchg_seqcst_acquire_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_weak_Int32" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int32_releasing_acquiring_weak(_:_:_:) + public func compareExchange2_Int32_releasing_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: Int32, + _ desired: Int32 + ) -> (exchanged: Bool, original: Int32) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int32" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int32_relaxed_sequential_weak(_:_:_:) + public func compareExchange2_Int32_relaxed_sequential_weak( + _ value: UnsafeAtomic, + _ expected: Int32, + _ desired: Int32 + ) -> (exchanged: Bool, original: Int32) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_weak_Int32" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int16_relaxed_relaxed_weak(_:_:_:) + public func compareExchange2_Int16_relaxed_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: Int16, + _ desired: Int16 + ) -> (exchanged: Bool, original: Int16) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int16" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int16_acquiring_relaxed_weak(_:_:_:) + public func compareExchange2_Int16_acquiring_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: Int16, + _ desired: Int16 + ) -> (exchanged: Bool, original: Int16) { + // CHECK: builtin "cmpxchg_acquire_monotonic_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int16" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int16_acquiring_acquiring_weak(_:_:_:) + public func compareExchange2_Int16_acquiring_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: Int16, + _ desired: Int16 + ) -> (exchanged: Bool, original: Int16) { + // CHECK: builtin "cmpxchg_acquire_acquire_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int16" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int16_sequential_acquiring_weak(_:_:_:) + public func compareExchange2_Int16_sequential_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: Int16, + _ desired: Int16 + ) -> (exchanged: Bool, original: Int16) { + // CHECK: builtin "cmpxchg_seqcst_acquire_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_weak_Int16" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int16_releasing_acquiring_weak(_:_:_:) + public func compareExchange2_Int16_releasing_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: Int16, + _ desired: Int16 + ) -> (exchanged: Bool, original: Int16) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int16" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int16_relaxed_sequential_weak(_:_:_:) + public func compareExchange2_Int16_relaxed_sequential_weak( + _ value: UnsafeAtomic, + _ expected: Int16, + _ desired: Int16 + ) -> (exchanged: Bool, original: Int16) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_weak_Int16" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int8_relaxed_relaxed_weak(_:_:_:) + public func compareExchange2_Int8_relaxed_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: Int8, + _ desired: Int8 + ) -> (exchanged: Bool, original: Int8) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int8" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int8_acquiring_relaxed_weak(_:_:_:) + public func compareExchange2_Int8_acquiring_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: Int8, + _ desired: Int8 + ) -> (exchanged: Bool, original: Int8) { + // CHECK: builtin "cmpxchg_acquire_monotonic_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int8" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int8_acquiring_acquiring_weak(_:_:_:) + public func compareExchange2_Int8_acquiring_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: Int8, + _ desired: Int8 + ) -> (exchanged: Bool, original: Int8) { + // CHECK: builtin "cmpxchg_acquire_acquire_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int8" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int8_sequential_acquiring_weak(_:_:_:) + public func compareExchange2_Int8_sequential_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: Int8, + _ desired: Int8 + ) -> (exchanged: Bool, original: Int8) { + // CHECK: builtin "cmpxchg_seqcst_acquire_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_weak_Int8" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int8_releasing_acquiring_weak(_:_:_:) + public func compareExchange2_Int8_releasing_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: Int8, + _ desired: Int8 + ) -> (exchanged: Bool, original: Int8) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int8" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Int8_relaxed_sequential_weak(_:_:_:) + public func compareExchange2_Int8_relaxed_sequential_weak( + _ value: UnsafeAtomic, + _ expected: Int8, + _ desired: Int8 + ) -> (exchanged: Bool, original: Int8) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_weak_Int8" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt_relaxed_relaxed_weak(_:_:_:) + public func compareExchange2_UInt_relaxed_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: UInt, + _ desired: UInt + ) -> (exchanged: Bool, original: UInt) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt_acquiring_relaxed_weak(_:_:_:) + public func compareExchange2_UInt_acquiring_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: UInt, + _ desired: UInt + ) -> (exchanged: Bool, original: UInt) { + // CHECK: builtin "cmpxchg_acquire_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt_acquiring_acquiring_weak(_:_:_:) + public func compareExchange2_UInt_acquiring_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: UInt, + _ desired: UInt + ) -> (exchanged: Bool, original: UInt) { + // CHECK: builtin "cmpxchg_acquire_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt_sequential_acquiring_weak(_:_:_:) + public func compareExchange2_UInt_sequential_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: UInt, + _ desired: UInt + ) -> (exchanged: Bool, original: UInt) { + // CHECK: builtin "cmpxchg_seqcst_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt_releasing_acquiring_weak(_:_:_:) + public func compareExchange2_UInt_releasing_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: UInt, + _ desired: UInt + ) -> (exchanged: Bool, original: UInt) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt_relaxed_sequential_weak(_:_:_:) + public func compareExchange2_UInt_relaxed_sequential_weak( + _ value: UnsafeAtomic, + _ expected: UInt, + _ desired: UInt + ) -> (exchanged: Bool, original: UInt) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt64_relaxed_relaxed_weak(_:_:_:) + public func compareExchange2_UInt64_relaxed_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: UInt64, + _ desired: UInt64 + ) -> (exchanged: Bool, original: UInt64) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int64" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt64_acquiring_relaxed_weak(_:_:_:) + public func compareExchange2_UInt64_acquiring_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: UInt64, + _ desired: UInt64 + ) -> (exchanged: Bool, original: UInt64) { + // CHECK: builtin "cmpxchg_acquire_monotonic_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int64" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt64_acquiring_acquiring_weak(_:_:_:) + public func compareExchange2_UInt64_acquiring_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: UInt64, + _ desired: UInt64 + ) -> (exchanged: Bool, original: UInt64) { + // CHECK: builtin "cmpxchg_acquire_acquire_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int64" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt64_sequential_acquiring_weak(_:_:_:) + public func compareExchange2_UInt64_sequential_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: UInt64, + _ desired: UInt64 + ) -> (exchanged: Bool, original: UInt64) { + // CHECK: builtin "cmpxchg_seqcst_acquire_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_weak_Int64" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt64_releasing_acquiring_weak(_:_:_:) + public func compareExchange2_UInt64_releasing_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: UInt64, + _ desired: UInt64 + ) -> (exchanged: Bool, original: UInt64) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int64" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt64_relaxed_sequential_weak(_:_:_:) + public func compareExchange2_UInt64_relaxed_sequential_weak( + _ value: UnsafeAtomic, + _ expected: UInt64, + _ desired: UInt64 + ) -> (exchanged: Bool, original: UInt64) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int64" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_weak_Int64" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt32_relaxed_relaxed_weak(_:_:_:) + public func compareExchange2_UInt32_relaxed_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: UInt32, + _ desired: UInt32 + ) -> (exchanged: Bool, original: UInt32) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int32" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt32_acquiring_relaxed_weak(_:_:_:) + public func compareExchange2_UInt32_acquiring_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: UInt32, + _ desired: UInt32 + ) -> (exchanged: Bool, original: UInt32) { + // CHECK: builtin "cmpxchg_acquire_monotonic_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int32" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt32_acquiring_acquiring_weak(_:_:_:) + public func compareExchange2_UInt32_acquiring_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: UInt32, + _ desired: UInt32 + ) -> (exchanged: Bool, original: UInt32) { + // CHECK: builtin "cmpxchg_acquire_acquire_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int32" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt32_sequential_acquiring_weak(_:_:_:) + public func compareExchange2_UInt32_sequential_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: UInt32, + _ desired: UInt32 + ) -> (exchanged: Bool, original: UInt32) { + // CHECK: builtin "cmpxchg_seqcst_acquire_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_weak_Int32" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt32_releasing_acquiring_weak(_:_:_:) + public func compareExchange2_UInt32_releasing_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: UInt32, + _ desired: UInt32 + ) -> (exchanged: Bool, original: UInt32) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int32" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt32_relaxed_sequential_weak(_:_:_:) + public func compareExchange2_UInt32_relaxed_sequential_weak( + _ value: UnsafeAtomic, + _ expected: UInt32, + _ desired: UInt32 + ) -> (exchanged: Bool, original: UInt32) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int32" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_weak_Int32" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt16_relaxed_relaxed_weak(_:_:_:) + public func compareExchange2_UInt16_relaxed_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: UInt16, + _ desired: UInt16 + ) -> (exchanged: Bool, original: UInt16) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int16" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt16_acquiring_relaxed_weak(_:_:_:) + public func compareExchange2_UInt16_acquiring_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: UInt16, + _ desired: UInt16 + ) -> (exchanged: Bool, original: UInt16) { + // CHECK: builtin "cmpxchg_acquire_monotonic_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int16" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt16_acquiring_acquiring_weak(_:_:_:) + public func compareExchange2_UInt16_acquiring_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: UInt16, + _ desired: UInt16 + ) -> (exchanged: Bool, original: UInt16) { + // CHECK: builtin "cmpxchg_acquire_acquire_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int16" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt16_sequential_acquiring_weak(_:_:_:) + public func compareExchange2_UInt16_sequential_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: UInt16, + _ desired: UInt16 + ) -> (exchanged: Bool, original: UInt16) { + // CHECK: builtin "cmpxchg_seqcst_acquire_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_weak_Int16" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt16_releasing_acquiring_weak(_:_:_:) + public func compareExchange2_UInt16_releasing_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: UInt16, + _ desired: UInt16 + ) -> (exchanged: Bool, original: UInt16) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int16" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt16_relaxed_sequential_weak(_:_:_:) + public func compareExchange2_UInt16_relaxed_sequential_weak( + _ value: UnsafeAtomic, + _ expected: UInt16, + _ desired: UInt16 + ) -> (exchanged: Bool, original: UInt16) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int16" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_weak_Int16" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt8_relaxed_relaxed_weak(_:_:_:) + public func compareExchange2_UInt8_relaxed_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: UInt8, + _ desired: UInt8 + ) -> (exchanged: Bool, original: UInt8) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int8" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt8_acquiring_relaxed_weak(_:_:_:) + public func compareExchange2_UInt8_acquiring_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: UInt8, + _ desired: UInt8 + ) -> (exchanged: Bool, original: UInt8) { + // CHECK: builtin "cmpxchg_acquire_monotonic_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int8" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt8_acquiring_acquiring_weak(_:_:_:) + public func compareExchange2_UInt8_acquiring_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: UInt8, + _ desired: UInt8 + ) -> (exchanged: Bool, original: UInt8) { + // CHECK: builtin "cmpxchg_acquire_acquire_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int8" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt8_sequential_acquiring_weak(_:_:_:) + public func compareExchange2_UInt8_sequential_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: UInt8, + _ desired: UInt8 + ) -> (exchanged: Bool, original: UInt8) { + // CHECK: builtin "cmpxchg_seqcst_acquire_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_weak_Int8" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt8_releasing_acquiring_weak(_:_:_:) + public func compareExchange2_UInt8_releasing_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: UInt8, + _ desired: UInt8 + ) -> (exchanged: Bool, original: UInt8) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Int8" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UInt8_relaxed_sequential_weak(_:_:_:) + public func compareExchange2_UInt8_relaxed_sequential_weak( + _ value: UnsafeAtomic, + _ expected: UInt8, + _ desired: UInt8 + ) -> (exchanged: Bool, original: UInt8) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Int8" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_weak_Int8" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeRawPointer_relaxed_relaxed_weak(_:_:_:) + public func compareExchange2_UnsafeRawPointer_relaxed_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: UnsafeRawPointer, + _ desired: UnsafeRawPointer + ) -> (exchanged: Bool, original: UnsafeRawPointer) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeRawPointer_acquiring_relaxed_weak(_:_:_:) + public func compareExchange2_UnsafeRawPointer_acquiring_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: UnsafeRawPointer, + _ desired: UnsafeRawPointer + ) -> (exchanged: Bool, original: UnsafeRawPointer) { + // CHECK: builtin "cmpxchg_acquire_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeRawPointer_acquiring_acquiring_weak(_:_:_:) + public func compareExchange2_UnsafeRawPointer_acquiring_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: UnsafeRawPointer, + _ desired: UnsafeRawPointer + ) -> (exchanged: Bool, original: UnsafeRawPointer) { + // CHECK: builtin "cmpxchg_acquire_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeRawPointer_sequential_acquiring_weak(_:_:_:) + public func compareExchange2_UnsafeRawPointer_sequential_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: UnsafeRawPointer, + _ desired: UnsafeRawPointer + ) -> (exchanged: Bool, original: UnsafeRawPointer) { + // CHECK: builtin "cmpxchg_seqcst_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeRawPointer_releasing_acquiring_weak(_:_:_:) + public func compareExchange2_UnsafeRawPointer_releasing_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: UnsafeRawPointer, + _ desired: UnsafeRawPointer + ) -> (exchanged: Bool, original: UnsafeRawPointer) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeRawPointer_relaxed_sequential_weak(_:_:_:) + public func compareExchange2_UnsafeRawPointer_relaxed_sequential_weak( + _ value: UnsafeAtomic, + _ expected: UnsafeRawPointer, + _ desired: UnsafeRawPointer + ) -> (exchanged: Bool, original: UnsafeRawPointer) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutableRawPointer_relaxed_relaxed_weak(_:_:_:) + public func compareExchange2_UnsafeMutableRawPointer_relaxed_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: UnsafeMutableRawPointer, + _ desired: UnsafeMutableRawPointer + ) -> (exchanged: Bool, original: UnsafeMutableRawPointer) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutableRawPointer_acquiring_relaxed_weak(_:_:_:) + public func compareExchange2_UnsafeMutableRawPointer_acquiring_relaxed_weak( + _ value: UnsafeAtomic, + _ expected: UnsafeMutableRawPointer, + _ desired: UnsafeMutableRawPointer + ) -> (exchanged: Bool, original: UnsafeMutableRawPointer) { + // CHECK: builtin "cmpxchg_acquire_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutableRawPointer_acquiring_acquiring_weak(_:_:_:) + public func compareExchange2_UnsafeMutableRawPointer_acquiring_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: UnsafeMutableRawPointer, + _ desired: UnsafeMutableRawPointer + ) -> (exchanged: Bool, original: UnsafeMutableRawPointer) { + // CHECK: builtin "cmpxchg_acquire_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutableRawPointer_sequential_acquiring_weak(_:_:_:) + public func compareExchange2_UnsafeMutableRawPointer_sequential_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: UnsafeMutableRawPointer, + _ desired: UnsafeMutableRawPointer + ) -> (exchanged: Bool, original: UnsafeMutableRawPointer) { + // CHECK: builtin "cmpxchg_seqcst_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutableRawPointer_releasing_acquiring_weak(_:_:_:) + public func compareExchange2_UnsafeMutableRawPointer_releasing_acquiring_weak( + _ value: UnsafeAtomic, + _ expected: UnsafeMutableRawPointer, + _ desired: UnsafeMutableRawPointer + ) -> (exchanged: Bool, original: UnsafeMutableRawPointer) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutableRawPointer_relaxed_sequential_weak(_:_:_:) + public func compareExchange2_UnsafeMutableRawPointer_relaxed_sequential_weak( + _ value: UnsafeAtomic, + _ expected: UnsafeMutableRawPointer, + _ desired: UnsafeMutableRawPointer + ) -> (exchanged: Bool, original: UnsafeMutableRawPointer) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafePointer_relaxed_relaxed_weak(_:_:_:) + public func compareExchange2_UnsafePointer_relaxed_relaxed_weak( + _ value: UnsafeAtomic>, + _ expected: UnsafePointer, + _ desired: UnsafePointer + ) -> (exchanged: Bool, original: UnsafePointer) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafePointer_acquiring_relaxed_weak(_:_:_:) + public func compareExchange2_UnsafePointer_acquiring_relaxed_weak( + _ value: UnsafeAtomic>, + _ expected: UnsafePointer, + _ desired: UnsafePointer + ) -> (exchanged: Bool, original: UnsafePointer) { + // CHECK: builtin "cmpxchg_acquire_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafePointer_acquiring_acquiring_weak(_:_:_:) + public func compareExchange2_UnsafePointer_acquiring_acquiring_weak( + _ value: UnsafeAtomic>, + _ expected: UnsafePointer, + _ desired: UnsafePointer + ) -> (exchanged: Bool, original: UnsafePointer) { + // CHECK: builtin "cmpxchg_acquire_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafePointer_sequential_acquiring_weak(_:_:_:) + public func compareExchange2_UnsafePointer_sequential_acquiring_weak( + _ value: UnsafeAtomic>, + _ expected: UnsafePointer, + _ desired: UnsafePointer + ) -> (exchanged: Bool, original: UnsafePointer) { + // CHECK: builtin "cmpxchg_seqcst_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafePointer_releasing_acquiring_weak(_:_:_:) + public func compareExchange2_UnsafePointer_releasing_acquiring_weak( + _ value: UnsafeAtomic>, + _ expected: UnsafePointer, + _ desired: UnsafePointer + ) -> (exchanged: Bool, original: UnsafePointer) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafePointer_relaxed_sequential_weak(_:_:_:) + public func compareExchange2_UnsafePointer_relaxed_sequential_weak( + _ value: UnsafeAtomic>, + _ expected: UnsafePointer, + _ desired: UnsafePointer + ) -> (exchanged: Bool, original: UnsafePointer) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutablePointer_relaxed_relaxed_weak(_:_:_:) + public func compareExchange2_UnsafeMutablePointer_relaxed_relaxed_weak( + _ value: UnsafeAtomic>, + _ expected: UnsafeMutablePointer, + _ desired: UnsafeMutablePointer + ) -> (exchanged: Bool, original: UnsafeMutablePointer) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutablePointer_acquiring_relaxed_weak(_:_:_:) + public func compareExchange2_UnsafeMutablePointer_acquiring_relaxed_weak( + _ value: UnsafeAtomic>, + _ expected: UnsafeMutablePointer, + _ desired: UnsafeMutablePointer + ) -> (exchanged: Bool, original: UnsafeMutablePointer) { + // CHECK: builtin "cmpxchg_acquire_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutablePointer_acquiring_acquiring_weak(_:_:_:) + public func compareExchange2_UnsafeMutablePointer_acquiring_acquiring_weak( + _ value: UnsafeAtomic>, + _ expected: UnsafeMutablePointer, + _ desired: UnsafeMutablePointer + ) -> (exchanged: Bool, original: UnsafeMutablePointer) { + // CHECK: builtin "cmpxchg_acquire_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutablePointer_sequential_acquiring_weak(_:_:_:) + public func compareExchange2_UnsafeMutablePointer_sequential_acquiring_weak( + _ value: UnsafeAtomic>, + _ expected: UnsafeMutablePointer, + _ desired: UnsafeMutablePointer + ) -> (exchanged: Bool, original: UnsafeMutablePointer) { + // CHECK: builtin "cmpxchg_seqcst_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutablePointer_releasing_acquiring_weak(_:_:_:) + public func compareExchange2_UnsafeMutablePointer_releasing_acquiring_weak( + _ value: UnsafeAtomic>, + _ expected: UnsafeMutablePointer, + _ desired: UnsafeMutablePointer + ) -> (exchanged: Bool, original: UnsafeMutablePointer) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_UnsafeMutablePointer_relaxed_sequential_weak(_:_:_:) + public func compareExchange2_UnsafeMutablePointer_relaxed_sequential_weak( + _ value: UnsafeAtomic>, + _ expected: UnsafeMutablePointer, + _ desired: UnsafeMutablePointer + ) -> (exchanged: Bool, original: UnsafeMutablePointer) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Unmanaged_relaxed_relaxed_weak(_:_:_:) + public func compareExchange2_Unmanaged_relaxed_relaxed_weak( + _ value: UnsafeAtomic>, + _ expected: Unmanaged, + _ desired: Unmanaged + ) -> (exchanged: Bool, original: Unmanaged) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Unmanaged_acquiring_relaxed_weak(_:_:_:) + public func compareExchange2_Unmanaged_acquiring_relaxed_weak( + _ value: UnsafeAtomic>, + _ expected: Unmanaged, + _ desired: Unmanaged + ) -> (exchanged: Bool, original: Unmanaged) { + // CHECK: builtin "cmpxchg_acquire_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Unmanaged_acquiring_acquiring_weak(_:_:_:) + public func compareExchange2_Unmanaged_acquiring_acquiring_weak( + _ value: UnsafeAtomic>, + _ expected: Unmanaged, + _ desired: Unmanaged + ) -> (exchanged: Bool, original: Unmanaged) { + // CHECK: builtin "cmpxchg_acquire_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Unmanaged_sequential_acquiring_weak(_:_:_:) + public func compareExchange2_Unmanaged_sequential_acquiring_weak( + _ value: UnsafeAtomic>, + _ expected: Unmanaged, + _ desired: Unmanaged + ) -> (exchanged: Bool, original: Unmanaged) { + // CHECK: builtin "cmpxchg_seqcst_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Unmanaged_releasing_acquiring_weak(_:_:_:) + public func compareExchange2_Unmanaged_releasing_acquiring_weak( + _ value: UnsafeAtomic>, + _ expected: Unmanaged, + _ desired: Unmanaged + ) -> (exchanged: Bool, original: Unmanaged) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_Unmanaged_relaxed_sequential_weak(_:_:_:) + public func compareExchange2_Unmanaged_relaxed_sequential_weak( + _ value: UnsafeAtomic>, + _ expected: Unmanaged, + _ desired: Unmanaged + ) -> (exchanged: Bool, original: Unmanaged) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeRawPointer_relaxed_relaxed_weak(_:_:_:) + public func compareExchange2_OptionalUnsafeRawPointer_relaxed_relaxed_weak( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeRawPointer_acquiring_relaxed_weak(_:_:_:) + public func compareExchange2_OptionalUnsafeRawPointer_acquiring_relaxed_weak( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // CHECK: builtin "cmpxchg_acquire_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeRawPointer_acquiring_acquiring_weak(_:_:_:) + public func compareExchange2_OptionalUnsafeRawPointer_acquiring_acquiring_weak( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // CHECK: builtin "cmpxchg_acquire_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeRawPointer_sequential_acquiring_weak(_:_:_:) + public func compareExchange2_OptionalUnsafeRawPointer_sequential_acquiring_weak( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // CHECK: builtin "cmpxchg_seqcst_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeRawPointer_releasing_acquiring_weak(_:_:_:) + public func compareExchange2_OptionalUnsafeRawPointer_releasing_acquiring_weak( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeRawPointer_relaxed_sequential_weak(_:_:_:) + public func compareExchange2_OptionalUnsafeRawPointer_relaxed_sequential_weak( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutableRawPointer_relaxed_relaxed_weak(_:_:_:) + public func compareExchange2_OptionalUnsafeMutableRawPointer_relaxed_relaxed_weak( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutableRawPointer_acquiring_relaxed_weak(_:_:_:) + public func compareExchange2_OptionalUnsafeMutableRawPointer_acquiring_relaxed_weak( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // CHECK: builtin "cmpxchg_acquire_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutableRawPointer_acquiring_acquiring_weak(_:_:_:) + public func compareExchange2_OptionalUnsafeMutableRawPointer_acquiring_acquiring_weak( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // CHECK: builtin "cmpxchg_acquire_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutableRawPointer_sequential_acquiring_weak(_:_:_:) + public func compareExchange2_OptionalUnsafeMutableRawPointer_sequential_acquiring_weak( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // CHECK: builtin "cmpxchg_seqcst_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutableRawPointer_releasing_acquiring_weak(_:_:_:) + public func compareExchange2_OptionalUnsafeMutableRawPointer_releasing_acquiring_weak( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutableRawPointer_relaxed_sequential_weak(_:_:_:) + public func compareExchange2_OptionalUnsafeMutableRawPointer_relaxed_sequential_weak( + _ value: UnsafeAtomic>, + _ expected: Optional, + _ desired: Optional + ) -> (exchanged: Bool, original: Optional) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafePointer_relaxed_relaxed_weak(_:_:_:) + public func compareExchange2_OptionalUnsafePointer_relaxed_relaxed_weak( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafePointer_acquiring_relaxed_weak(_:_:_:) + public func compareExchange2_OptionalUnsafePointer_acquiring_relaxed_weak( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_acquire_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafePointer_acquiring_acquiring_weak(_:_:_:) + public func compareExchange2_OptionalUnsafePointer_acquiring_acquiring_weak( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_acquire_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafePointer_sequential_acquiring_weak(_:_:_:) + public func compareExchange2_OptionalUnsafePointer_sequential_acquiring_weak( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_seqcst_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafePointer_releasing_acquiring_weak(_:_:_:) + public func compareExchange2_OptionalUnsafePointer_releasing_acquiring_weak( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafePointer_relaxed_sequential_weak(_:_:_:) + public func compareExchange2_OptionalUnsafePointer_relaxed_sequential_weak( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutablePointer_relaxed_relaxed_weak(_:_:_:) + public func compareExchange2_OptionalUnsafeMutablePointer_relaxed_relaxed_weak( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutablePointer_acquiring_relaxed_weak(_:_:_:) + public func compareExchange2_OptionalUnsafeMutablePointer_acquiring_relaxed_weak( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_acquire_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutablePointer_acquiring_acquiring_weak(_:_:_:) + public func compareExchange2_OptionalUnsafeMutablePointer_acquiring_acquiring_weak( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_acquire_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutablePointer_sequential_acquiring_weak(_:_:_:) + public func compareExchange2_OptionalUnsafeMutablePointer_sequential_acquiring_weak( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_seqcst_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutablePointer_releasing_acquiring_weak(_:_:_:) + public func compareExchange2_OptionalUnsafeMutablePointer_releasing_acquiring_weak( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnsafeMutablePointer_relaxed_sequential_weak(_:_:_:) + public func compareExchange2_OptionalUnsafeMutablePointer_relaxed_sequential_weak( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnmanaged_relaxed_relaxed_weak(_:_:_:) + public func compareExchange2_OptionalUnmanaged_relaxed_relaxed_weak( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_monotonic_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnmanaged_acquiring_relaxed_weak(_:_:_:) + public func compareExchange2_OptionalUnmanaged_acquiring_relaxed_weak( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_acquire_monotonic_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^m][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnmanaged_acquiring_acquiring_weak(_:_:_:) + public func compareExchange2_OptionalUnmanaged_acquiring_acquiring_weak( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_acquire_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .acquiring, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnmanaged_sequential_acquiring_weak(_:_:_:) + public func compareExchange2_OptionalUnmanaged_sequential_acquiring_weak( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // CHECK: builtin "cmpxchg_seqcst_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^a][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .sequentiallyConsistent, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnmanaged_releasing_acquiring_weak(_:_:_:) + public func compareExchange2_OptionalUnmanaged_releasing_acquiring_weak( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // FIXME: This should be checking for "cmpxchg_release_acquire", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_acqrel_acquire_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[^a][a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .releasing, + failureOrdering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.compareExchange2_OptionalUnmanaged_relaxed_sequential_weak(_:_:_:) + public func compareExchange2_OptionalUnmanaged_relaxed_sequential_weak( + _ value: UnsafeAtomic>>, + _ expected: Optional>, + _ desired: Optional> + ) -> (exchanged: Bool, original: Optional>) { + // FIXME: This should be checking for "cmpxchg_monotonic_seqcst", but we don't + // support arbitrary failure orderings yet, so internally we promote success + // orderings to be at least as strong as the failure ordering. + + // CHECK: builtin "cmpxchg_seqcst_seqcst_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_monotonic_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acquire_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_release_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_acqrel_{{[a-z0-9_]*}}_weak_Word" + // EXCLUSIONS-NOT: builtin "cmpxchg_seqcst_{{[^s][a-z0-9_]*}}_weak_Word" + return value.weakCompareExchange( + expected: expected, + desired: desired, + successOrdering: .relaxed, + failureOrdering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // --------------------------------------------------------------------------- + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int_relaxed(_:_:) + public func loadThenWrappingIncrement_Int_relaxed( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_add_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Word" + return value.loadThenWrappingIncrement(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int_acquiring(_:_:) + public func loadThenWrappingIncrement_Int_acquiring( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_add_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Word" + return value.loadThenWrappingIncrement(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int_releasing(_:_:) + public func loadThenWrappingIncrement_Int_releasing( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_add_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Word" + return value.loadThenWrappingIncrement(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int_acquiringAndReleasing(_:_:) + public func loadThenWrappingIncrement_Int_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_add_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Word" + return value.loadThenWrappingIncrement( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int_sequential(_:_:) + public func loadThenWrappingIncrement_Int_sequential( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_add_seqcst_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Word" + return value.loadThenWrappingIncrement( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int_relaxed(_:_:) + public func loadThenWrappingDecrement_Int_relaxed( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_sub_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Word" + return value.loadThenWrappingDecrement(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int_acquiring(_:_:) + public func loadThenWrappingDecrement_Int_acquiring( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_sub_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Word" + return value.loadThenWrappingDecrement(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int_releasing(_:_:) + public func loadThenWrappingDecrement_Int_releasing( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_sub_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Word" + return value.loadThenWrappingDecrement(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int_acquiringAndReleasing(_:_:) + public func loadThenWrappingDecrement_Int_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_sub_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Word" + return value.loadThenWrappingDecrement( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int_sequential(_:_:) + public func loadThenWrappingDecrement_Int_sequential( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_sub_seqcst_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Word" + return value.loadThenWrappingDecrement( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int_relaxed(_:_:) + public func loadThenBitwiseAnd_Int_relaxed( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_and_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Word" + return value.loadThenBitwiseAnd(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int_acquiring(_:_:) + public func loadThenBitwiseAnd_Int_acquiring( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_and_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Word" + return value.loadThenBitwiseAnd(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int_releasing(_:_:) + public func loadThenBitwiseAnd_Int_releasing( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_and_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Word" + return value.loadThenBitwiseAnd(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int_acquiringAndReleasing(_:_:) + public func loadThenBitwiseAnd_Int_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_and_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Word" + return value.loadThenBitwiseAnd( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int_sequential(_:_:) + public func loadThenBitwiseAnd_Int_sequential( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_and_seqcst_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Word" + return value.loadThenBitwiseAnd( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int_relaxed(_:_:) + public func loadThenBitwiseOr_Int_relaxed( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_or_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Word" + return value.loadThenBitwiseOr(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int_acquiring(_:_:) + public func loadThenBitwiseOr_Int_acquiring( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_or_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Word" + return value.loadThenBitwiseOr(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int_releasing(_:_:) + public func loadThenBitwiseOr_Int_releasing( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_or_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Word" + return value.loadThenBitwiseOr(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int_acquiringAndReleasing(_:_:) + public func loadThenBitwiseOr_Int_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_or_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Word" + return value.loadThenBitwiseOr( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int_sequential(_:_:) + public func loadThenBitwiseOr_Int_sequential( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_or_seqcst_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Word" + return value.loadThenBitwiseOr( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int_relaxed(_:_:) + public func loadThenBitwiseXor_Int_relaxed( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_xor_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Word" + return value.loadThenBitwiseXor(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int_acquiring(_:_:) + public func loadThenBitwiseXor_Int_acquiring( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_xor_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Word" + return value.loadThenBitwiseXor(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int_releasing(_:_:) + public func loadThenBitwiseXor_Int_releasing( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_xor_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Word" + return value.loadThenBitwiseXor(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int_acquiringAndReleasing(_:_:) + public func loadThenBitwiseXor_Int_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_xor_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Word" + return value.loadThenBitwiseXor( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int_sequential(_:_:) + public func loadThenBitwiseXor_Int_sequential( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_xor_seqcst_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Word" + return value.loadThenBitwiseXor( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int_relaxed(_:_:) + public func wrappingIncrementThenLoad_Int_relaxed( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_add_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Word" + return value.wrappingIncrementThenLoad(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int_acquiring(_:_:) + public func wrappingIncrementThenLoad_Int_acquiring( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_add_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Word" + return value.wrappingIncrementThenLoad(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int_releasing(_:_:) + public func wrappingIncrementThenLoad_Int_releasing( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_add_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Word" + return value.wrappingIncrementThenLoad(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int_acquiringAndReleasing(_:_:) + public func wrappingIncrementThenLoad_Int_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_add_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Word" + return value.wrappingIncrementThenLoad( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int_sequential(_:_:) + public func wrappingIncrementThenLoad_Int_sequential( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_add_seqcst_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Word" + return value.wrappingIncrementThenLoad( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int_relaxed(_:_:) + public func wrappingDecrementThenLoad_Int_relaxed( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_sub_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Word" + return value.wrappingDecrementThenLoad(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int_acquiring(_:_:) + public func wrappingDecrementThenLoad_Int_acquiring( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_sub_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Word" + return value.wrappingDecrementThenLoad(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int_releasing(_:_:) + public func wrappingDecrementThenLoad_Int_releasing( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_sub_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Word" + return value.wrappingDecrementThenLoad(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int_acquiringAndReleasing(_:_:) + public func wrappingDecrementThenLoad_Int_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_sub_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Word" + return value.wrappingDecrementThenLoad( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int_sequential(_:_:) + public func wrappingDecrementThenLoad_Int_sequential( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_sub_seqcst_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Word" + return value.wrappingDecrementThenLoad( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int_relaxed(_:_:) + public func bitwiseAndThenLoad_Int_relaxed( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_and_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Word" + return value.bitwiseAndThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int_acquiring(_:_:) + public func bitwiseAndThenLoad_Int_acquiring( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_and_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Word" + return value.bitwiseAndThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int_releasing(_:_:) + public func bitwiseAndThenLoad_Int_releasing( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_and_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Word" + return value.bitwiseAndThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int_acquiringAndReleasing(_:_:) + public func bitwiseAndThenLoad_Int_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_and_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Word" + return value.bitwiseAndThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int_sequential(_:_:) + public func bitwiseAndThenLoad_Int_sequential( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_and_seqcst_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Word" + return value.bitwiseAndThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int_relaxed(_:_:) + public func bitwiseOrThenLoad_Int_relaxed( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_or_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Word" + return value.bitwiseOrThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int_acquiring(_:_:) + public func bitwiseOrThenLoad_Int_acquiring( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_or_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Word" + return value.bitwiseOrThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int_releasing(_:_:) + public func bitwiseOrThenLoad_Int_releasing( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_or_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Word" + return value.bitwiseOrThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int_acquiringAndReleasing(_:_:) + public func bitwiseOrThenLoad_Int_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_or_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Word" + return value.bitwiseOrThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int_sequential(_:_:) + public func bitwiseOrThenLoad_Int_sequential( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_or_seqcst_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Word" + return value.bitwiseOrThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int_relaxed(_:_:) + public func bitwiseXorThenLoad_Int_relaxed( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_xor_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Word" + return value.bitwiseXorThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int_acquiring(_:_:) + public func bitwiseXorThenLoad_Int_acquiring( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_xor_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Word" + return value.bitwiseXorThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int_releasing(_:_:) + public func bitwiseXorThenLoad_Int_releasing( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_xor_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Word" + return value.bitwiseXorThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int_acquiringAndReleasing(_:_:) + public func bitwiseXorThenLoad_Int_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_xor_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Word" + return value.bitwiseXorThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int_sequential(_:_:) + public func bitwiseXorThenLoad_Int_sequential( + _ value: UnsafeAtomic, + _ operand: Int + ) -> Int { + // CHECK: builtin "atomicrmw_xor_seqcst_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Word" + return value.bitwiseXorThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int64_relaxed(_:_:) + public func loadThenWrappingIncrement_Int64_relaxed( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_add_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int64" + return value.loadThenWrappingIncrement(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int64_acquiring(_:_:) + public func loadThenWrappingIncrement_Int64_acquiring( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_add_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int64" + return value.loadThenWrappingIncrement(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int64_releasing(_:_:) + public func loadThenWrappingIncrement_Int64_releasing( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_add_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int64" + return value.loadThenWrappingIncrement(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int64_acquiringAndReleasing(_:_:) + public func loadThenWrappingIncrement_Int64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_add_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int64" + return value.loadThenWrappingIncrement( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int64_sequential(_:_:) + public func loadThenWrappingIncrement_Int64_sequential( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_add_seqcst_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int64" + return value.loadThenWrappingIncrement( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int64_relaxed(_:_:) + public func loadThenWrappingDecrement_Int64_relaxed( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_sub_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int64" + return value.loadThenWrappingDecrement(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int64_acquiring(_:_:) + public func loadThenWrappingDecrement_Int64_acquiring( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_sub_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int64" + return value.loadThenWrappingDecrement(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int64_releasing(_:_:) + public func loadThenWrappingDecrement_Int64_releasing( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_sub_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int64" + return value.loadThenWrappingDecrement(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int64_acquiringAndReleasing(_:_:) + public func loadThenWrappingDecrement_Int64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_sub_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int64" + return value.loadThenWrappingDecrement( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int64_sequential(_:_:) + public func loadThenWrappingDecrement_Int64_sequential( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_sub_seqcst_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int64" + return value.loadThenWrappingDecrement( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int64_relaxed(_:_:) + public func loadThenBitwiseAnd_Int64_relaxed( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_and_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int64" + return value.loadThenBitwiseAnd(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int64_acquiring(_:_:) + public func loadThenBitwiseAnd_Int64_acquiring( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_and_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int64" + return value.loadThenBitwiseAnd(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int64_releasing(_:_:) + public func loadThenBitwiseAnd_Int64_releasing( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_and_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int64" + return value.loadThenBitwiseAnd(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int64_acquiringAndReleasing(_:_:) + public func loadThenBitwiseAnd_Int64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_and_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int64" + return value.loadThenBitwiseAnd( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int64_sequential(_:_:) + public func loadThenBitwiseAnd_Int64_sequential( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_and_seqcst_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int64" + return value.loadThenBitwiseAnd( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int64_relaxed(_:_:) + public func loadThenBitwiseOr_Int64_relaxed( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_or_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int64" + return value.loadThenBitwiseOr(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int64_acquiring(_:_:) + public func loadThenBitwiseOr_Int64_acquiring( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_or_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int64" + return value.loadThenBitwiseOr(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int64_releasing(_:_:) + public func loadThenBitwiseOr_Int64_releasing( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_or_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int64" + return value.loadThenBitwiseOr(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int64_acquiringAndReleasing(_:_:) + public func loadThenBitwiseOr_Int64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_or_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int64" + return value.loadThenBitwiseOr( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int64_sequential(_:_:) + public func loadThenBitwiseOr_Int64_sequential( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_or_seqcst_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int64" + return value.loadThenBitwiseOr( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int64_relaxed(_:_:) + public func loadThenBitwiseXor_Int64_relaxed( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_xor_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int64" + return value.loadThenBitwiseXor(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int64_acquiring(_:_:) + public func loadThenBitwiseXor_Int64_acquiring( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_xor_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int64" + return value.loadThenBitwiseXor(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int64_releasing(_:_:) + public func loadThenBitwiseXor_Int64_releasing( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_xor_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int64" + return value.loadThenBitwiseXor(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int64_acquiringAndReleasing(_:_:) + public func loadThenBitwiseXor_Int64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_xor_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int64" + return value.loadThenBitwiseXor( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int64_sequential(_:_:) + public func loadThenBitwiseXor_Int64_sequential( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_xor_seqcst_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int64" + return value.loadThenBitwiseXor( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int64_relaxed(_:_:) + public func wrappingIncrementThenLoad_Int64_relaxed( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_add_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int64" + return value.wrappingIncrementThenLoad(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int64_acquiring(_:_:) + public func wrappingIncrementThenLoad_Int64_acquiring( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_add_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int64" + return value.wrappingIncrementThenLoad(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int64_releasing(_:_:) + public func wrappingIncrementThenLoad_Int64_releasing( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_add_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int64" + return value.wrappingIncrementThenLoad(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int64_acquiringAndReleasing(_:_:) + public func wrappingIncrementThenLoad_Int64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_add_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int64" + return value.wrappingIncrementThenLoad( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int64_sequential(_:_:) + public func wrappingIncrementThenLoad_Int64_sequential( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_add_seqcst_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int64" + return value.wrappingIncrementThenLoad( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int64_relaxed(_:_:) + public func wrappingDecrementThenLoad_Int64_relaxed( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_sub_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int64" + return value.wrappingDecrementThenLoad(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int64_acquiring(_:_:) + public func wrappingDecrementThenLoad_Int64_acquiring( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_sub_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int64" + return value.wrappingDecrementThenLoad(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int64_releasing(_:_:) + public func wrappingDecrementThenLoad_Int64_releasing( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_sub_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int64" + return value.wrappingDecrementThenLoad(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int64_acquiringAndReleasing(_:_:) + public func wrappingDecrementThenLoad_Int64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_sub_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int64" + return value.wrappingDecrementThenLoad( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int64_sequential(_:_:) + public func wrappingDecrementThenLoad_Int64_sequential( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_sub_seqcst_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int64" + return value.wrappingDecrementThenLoad( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int64_relaxed(_:_:) + public func bitwiseAndThenLoad_Int64_relaxed( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_and_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int64" + return value.bitwiseAndThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int64_acquiring(_:_:) + public func bitwiseAndThenLoad_Int64_acquiring( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_and_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int64" + return value.bitwiseAndThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int64_releasing(_:_:) + public func bitwiseAndThenLoad_Int64_releasing( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_and_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int64" + return value.bitwiseAndThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int64_acquiringAndReleasing(_:_:) + public func bitwiseAndThenLoad_Int64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_and_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int64" + return value.bitwiseAndThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int64_sequential(_:_:) + public func bitwiseAndThenLoad_Int64_sequential( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_and_seqcst_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int64" + return value.bitwiseAndThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int64_relaxed(_:_:) + public func bitwiseOrThenLoad_Int64_relaxed( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_or_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int64" + return value.bitwiseOrThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int64_acquiring(_:_:) + public func bitwiseOrThenLoad_Int64_acquiring( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_or_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int64" + return value.bitwiseOrThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int64_releasing(_:_:) + public func bitwiseOrThenLoad_Int64_releasing( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_or_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int64" + return value.bitwiseOrThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int64_acquiringAndReleasing(_:_:) + public func bitwiseOrThenLoad_Int64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_or_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int64" + return value.bitwiseOrThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int64_sequential(_:_:) + public func bitwiseOrThenLoad_Int64_sequential( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_or_seqcst_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int64" + return value.bitwiseOrThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int64_relaxed(_:_:) + public func bitwiseXorThenLoad_Int64_relaxed( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_xor_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int64" + return value.bitwiseXorThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int64_acquiring(_:_:) + public func bitwiseXorThenLoad_Int64_acquiring( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_xor_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int64" + return value.bitwiseXorThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int64_releasing(_:_:) + public func bitwiseXorThenLoad_Int64_releasing( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_xor_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int64" + return value.bitwiseXorThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int64_acquiringAndReleasing(_:_:) + public func bitwiseXorThenLoad_Int64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_xor_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int64" + return value.bitwiseXorThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int64_sequential(_:_:) + public func bitwiseXorThenLoad_Int64_sequential( + _ value: UnsafeAtomic, + _ operand: Int64 + ) -> Int64 { + // CHECK: builtin "atomicrmw_xor_seqcst_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int64" + return value.bitwiseXorThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int32_relaxed(_:_:) + public func loadThenWrappingIncrement_Int32_relaxed( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_add_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int32" + return value.loadThenWrappingIncrement(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int32_acquiring(_:_:) + public func loadThenWrappingIncrement_Int32_acquiring( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_add_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int32" + return value.loadThenWrappingIncrement(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int32_releasing(_:_:) + public func loadThenWrappingIncrement_Int32_releasing( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_add_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int32" + return value.loadThenWrappingIncrement(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int32_acquiringAndReleasing(_:_:) + public func loadThenWrappingIncrement_Int32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_add_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int32" + return value.loadThenWrappingIncrement( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int32_sequential(_:_:) + public func loadThenWrappingIncrement_Int32_sequential( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_add_seqcst_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int32" + return value.loadThenWrappingIncrement( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int32_relaxed(_:_:) + public func loadThenWrappingDecrement_Int32_relaxed( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_sub_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int32" + return value.loadThenWrappingDecrement(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int32_acquiring(_:_:) + public func loadThenWrappingDecrement_Int32_acquiring( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_sub_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int32" + return value.loadThenWrappingDecrement(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int32_releasing(_:_:) + public func loadThenWrappingDecrement_Int32_releasing( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_sub_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int32" + return value.loadThenWrappingDecrement(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int32_acquiringAndReleasing(_:_:) + public func loadThenWrappingDecrement_Int32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_sub_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int32" + return value.loadThenWrappingDecrement( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int32_sequential(_:_:) + public func loadThenWrappingDecrement_Int32_sequential( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_sub_seqcst_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int32" + return value.loadThenWrappingDecrement( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int32_relaxed(_:_:) + public func loadThenBitwiseAnd_Int32_relaxed( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_and_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int32" + return value.loadThenBitwiseAnd(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int32_acquiring(_:_:) + public func loadThenBitwiseAnd_Int32_acquiring( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_and_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int32" + return value.loadThenBitwiseAnd(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int32_releasing(_:_:) + public func loadThenBitwiseAnd_Int32_releasing( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_and_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int32" + return value.loadThenBitwiseAnd(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int32_acquiringAndReleasing(_:_:) + public func loadThenBitwiseAnd_Int32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_and_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int32" + return value.loadThenBitwiseAnd( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int32_sequential(_:_:) + public func loadThenBitwiseAnd_Int32_sequential( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_and_seqcst_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int32" + return value.loadThenBitwiseAnd( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int32_relaxed(_:_:) + public func loadThenBitwiseOr_Int32_relaxed( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_or_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int32" + return value.loadThenBitwiseOr(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int32_acquiring(_:_:) + public func loadThenBitwiseOr_Int32_acquiring( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_or_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int32" + return value.loadThenBitwiseOr(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int32_releasing(_:_:) + public func loadThenBitwiseOr_Int32_releasing( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_or_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int32" + return value.loadThenBitwiseOr(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int32_acquiringAndReleasing(_:_:) + public func loadThenBitwiseOr_Int32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_or_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int32" + return value.loadThenBitwiseOr( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int32_sequential(_:_:) + public func loadThenBitwiseOr_Int32_sequential( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_or_seqcst_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int32" + return value.loadThenBitwiseOr( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int32_relaxed(_:_:) + public func loadThenBitwiseXor_Int32_relaxed( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_xor_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int32" + return value.loadThenBitwiseXor(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int32_acquiring(_:_:) + public func loadThenBitwiseXor_Int32_acquiring( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_xor_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int32" + return value.loadThenBitwiseXor(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int32_releasing(_:_:) + public func loadThenBitwiseXor_Int32_releasing( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_xor_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int32" + return value.loadThenBitwiseXor(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int32_acquiringAndReleasing(_:_:) + public func loadThenBitwiseXor_Int32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_xor_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int32" + return value.loadThenBitwiseXor( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int32_sequential(_:_:) + public func loadThenBitwiseXor_Int32_sequential( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_xor_seqcst_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int32" + return value.loadThenBitwiseXor( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int32_relaxed(_:_:) + public func wrappingIncrementThenLoad_Int32_relaxed( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_add_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int32" + return value.wrappingIncrementThenLoad(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int32_acquiring(_:_:) + public func wrappingIncrementThenLoad_Int32_acquiring( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_add_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int32" + return value.wrappingIncrementThenLoad(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int32_releasing(_:_:) + public func wrappingIncrementThenLoad_Int32_releasing( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_add_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int32" + return value.wrappingIncrementThenLoad(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int32_acquiringAndReleasing(_:_:) + public func wrappingIncrementThenLoad_Int32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_add_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int32" + return value.wrappingIncrementThenLoad( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int32_sequential(_:_:) + public func wrappingIncrementThenLoad_Int32_sequential( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_add_seqcst_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int32" + return value.wrappingIncrementThenLoad( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int32_relaxed(_:_:) + public func wrappingDecrementThenLoad_Int32_relaxed( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_sub_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int32" + return value.wrappingDecrementThenLoad(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int32_acquiring(_:_:) + public func wrappingDecrementThenLoad_Int32_acquiring( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_sub_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int32" + return value.wrappingDecrementThenLoad(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int32_releasing(_:_:) + public func wrappingDecrementThenLoad_Int32_releasing( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_sub_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int32" + return value.wrappingDecrementThenLoad(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int32_acquiringAndReleasing(_:_:) + public func wrappingDecrementThenLoad_Int32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_sub_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int32" + return value.wrappingDecrementThenLoad( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int32_sequential(_:_:) + public func wrappingDecrementThenLoad_Int32_sequential( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_sub_seqcst_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int32" + return value.wrappingDecrementThenLoad( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int32_relaxed(_:_:) + public func bitwiseAndThenLoad_Int32_relaxed( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_and_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int32" + return value.bitwiseAndThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int32_acquiring(_:_:) + public func bitwiseAndThenLoad_Int32_acquiring( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_and_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int32" + return value.bitwiseAndThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int32_releasing(_:_:) + public func bitwiseAndThenLoad_Int32_releasing( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_and_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int32" + return value.bitwiseAndThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int32_acquiringAndReleasing(_:_:) + public func bitwiseAndThenLoad_Int32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_and_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int32" + return value.bitwiseAndThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int32_sequential(_:_:) + public func bitwiseAndThenLoad_Int32_sequential( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_and_seqcst_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int32" + return value.bitwiseAndThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int32_relaxed(_:_:) + public func bitwiseOrThenLoad_Int32_relaxed( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_or_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int32" + return value.bitwiseOrThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int32_acquiring(_:_:) + public func bitwiseOrThenLoad_Int32_acquiring( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_or_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int32" + return value.bitwiseOrThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int32_releasing(_:_:) + public func bitwiseOrThenLoad_Int32_releasing( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_or_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int32" + return value.bitwiseOrThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int32_acquiringAndReleasing(_:_:) + public func bitwiseOrThenLoad_Int32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_or_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int32" + return value.bitwiseOrThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int32_sequential(_:_:) + public func bitwiseOrThenLoad_Int32_sequential( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_or_seqcst_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int32" + return value.bitwiseOrThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int32_relaxed(_:_:) + public func bitwiseXorThenLoad_Int32_relaxed( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_xor_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int32" + return value.bitwiseXorThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int32_acquiring(_:_:) + public func bitwiseXorThenLoad_Int32_acquiring( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_xor_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int32" + return value.bitwiseXorThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int32_releasing(_:_:) + public func bitwiseXorThenLoad_Int32_releasing( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_xor_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int32" + return value.bitwiseXorThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int32_acquiringAndReleasing(_:_:) + public func bitwiseXorThenLoad_Int32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_xor_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int32" + return value.bitwiseXorThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int32_sequential(_:_:) + public func bitwiseXorThenLoad_Int32_sequential( + _ value: UnsafeAtomic, + _ operand: Int32 + ) -> Int32 { + // CHECK: builtin "atomicrmw_xor_seqcst_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int32" + return value.bitwiseXorThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int16_relaxed(_:_:) + public func loadThenWrappingIncrement_Int16_relaxed( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_add_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int16" + return value.loadThenWrappingIncrement(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int16_acquiring(_:_:) + public func loadThenWrappingIncrement_Int16_acquiring( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_add_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int16" + return value.loadThenWrappingIncrement(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int16_releasing(_:_:) + public func loadThenWrappingIncrement_Int16_releasing( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_add_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int16" + return value.loadThenWrappingIncrement(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int16_acquiringAndReleasing(_:_:) + public func loadThenWrappingIncrement_Int16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_add_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int16" + return value.loadThenWrappingIncrement( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int16_sequential(_:_:) + public func loadThenWrappingIncrement_Int16_sequential( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_add_seqcst_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int16" + return value.loadThenWrappingIncrement( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int16_relaxed(_:_:) + public func loadThenWrappingDecrement_Int16_relaxed( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_sub_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int16" + return value.loadThenWrappingDecrement(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int16_acquiring(_:_:) + public func loadThenWrappingDecrement_Int16_acquiring( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_sub_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int16" + return value.loadThenWrappingDecrement(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int16_releasing(_:_:) + public func loadThenWrappingDecrement_Int16_releasing( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_sub_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int16" + return value.loadThenWrappingDecrement(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int16_acquiringAndReleasing(_:_:) + public func loadThenWrappingDecrement_Int16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_sub_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int16" + return value.loadThenWrappingDecrement( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int16_sequential(_:_:) + public func loadThenWrappingDecrement_Int16_sequential( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_sub_seqcst_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int16" + return value.loadThenWrappingDecrement( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int16_relaxed(_:_:) + public func loadThenBitwiseAnd_Int16_relaxed( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_and_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int16" + return value.loadThenBitwiseAnd(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int16_acquiring(_:_:) + public func loadThenBitwiseAnd_Int16_acquiring( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_and_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int16" + return value.loadThenBitwiseAnd(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int16_releasing(_:_:) + public func loadThenBitwiseAnd_Int16_releasing( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_and_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int16" + return value.loadThenBitwiseAnd(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int16_acquiringAndReleasing(_:_:) + public func loadThenBitwiseAnd_Int16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_and_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int16" + return value.loadThenBitwiseAnd( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int16_sequential(_:_:) + public func loadThenBitwiseAnd_Int16_sequential( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_and_seqcst_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int16" + return value.loadThenBitwiseAnd( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int16_relaxed(_:_:) + public func loadThenBitwiseOr_Int16_relaxed( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_or_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int16" + return value.loadThenBitwiseOr(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int16_acquiring(_:_:) + public func loadThenBitwiseOr_Int16_acquiring( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_or_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int16" + return value.loadThenBitwiseOr(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int16_releasing(_:_:) + public func loadThenBitwiseOr_Int16_releasing( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_or_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int16" + return value.loadThenBitwiseOr(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int16_acquiringAndReleasing(_:_:) + public func loadThenBitwiseOr_Int16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_or_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int16" + return value.loadThenBitwiseOr( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int16_sequential(_:_:) + public func loadThenBitwiseOr_Int16_sequential( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_or_seqcst_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int16" + return value.loadThenBitwiseOr( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int16_relaxed(_:_:) + public func loadThenBitwiseXor_Int16_relaxed( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_xor_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int16" + return value.loadThenBitwiseXor(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int16_acquiring(_:_:) + public func loadThenBitwiseXor_Int16_acquiring( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_xor_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int16" + return value.loadThenBitwiseXor(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int16_releasing(_:_:) + public func loadThenBitwiseXor_Int16_releasing( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_xor_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int16" + return value.loadThenBitwiseXor(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int16_acquiringAndReleasing(_:_:) + public func loadThenBitwiseXor_Int16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_xor_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int16" + return value.loadThenBitwiseXor( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int16_sequential(_:_:) + public func loadThenBitwiseXor_Int16_sequential( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_xor_seqcst_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int16" + return value.loadThenBitwiseXor( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int16_relaxed(_:_:) + public func wrappingIncrementThenLoad_Int16_relaxed( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_add_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int16" + return value.wrappingIncrementThenLoad(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int16_acquiring(_:_:) + public func wrappingIncrementThenLoad_Int16_acquiring( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_add_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int16" + return value.wrappingIncrementThenLoad(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int16_releasing(_:_:) + public func wrappingIncrementThenLoad_Int16_releasing( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_add_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int16" + return value.wrappingIncrementThenLoad(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int16_acquiringAndReleasing(_:_:) + public func wrappingIncrementThenLoad_Int16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_add_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int16" + return value.wrappingIncrementThenLoad( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int16_sequential(_:_:) + public func wrappingIncrementThenLoad_Int16_sequential( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_add_seqcst_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int16" + return value.wrappingIncrementThenLoad( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int16_relaxed(_:_:) + public func wrappingDecrementThenLoad_Int16_relaxed( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_sub_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int16" + return value.wrappingDecrementThenLoad(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int16_acquiring(_:_:) + public func wrappingDecrementThenLoad_Int16_acquiring( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_sub_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int16" + return value.wrappingDecrementThenLoad(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int16_releasing(_:_:) + public func wrappingDecrementThenLoad_Int16_releasing( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_sub_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int16" + return value.wrappingDecrementThenLoad(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int16_acquiringAndReleasing(_:_:) + public func wrappingDecrementThenLoad_Int16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_sub_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int16" + return value.wrappingDecrementThenLoad( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int16_sequential(_:_:) + public func wrappingDecrementThenLoad_Int16_sequential( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_sub_seqcst_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int16" + return value.wrappingDecrementThenLoad( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int16_relaxed(_:_:) + public func bitwiseAndThenLoad_Int16_relaxed( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_and_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int16" + return value.bitwiseAndThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int16_acquiring(_:_:) + public func bitwiseAndThenLoad_Int16_acquiring( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_and_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int16" + return value.bitwiseAndThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int16_releasing(_:_:) + public func bitwiseAndThenLoad_Int16_releasing( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_and_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int16" + return value.bitwiseAndThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int16_acquiringAndReleasing(_:_:) + public func bitwiseAndThenLoad_Int16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_and_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int16" + return value.bitwiseAndThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int16_sequential(_:_:) + public func bitwiseAndThenLoad_Int16_sequential( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_and_seqcst_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int16" + return value.bitwiseAndThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int16_relaxed(_:_:) + public func bitwiseOrThenLoad_Int16_relaxed( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_or_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int16" + return value.bitwiseOrThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int16_acquiring(_:_:) + public func bitwiseOrThenLoad_Int16_acquiring( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_or_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int16" + return value.bitwiseOrThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int16_releasing(_:_:) + public func bitwiseOrThenLoad_Int16_releasing( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_or_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int16" + return value.bitwiseOrThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int16_acquiringAndReleasing(_:_:) + public func bitwiseOrThenLoad_Int16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_or_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int16" + return value.bitwiseOrThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int16_sequential(_:_:) + public func bitwiseOrThenLoad_Int16_sequential( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_or_seqcst_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int16" + return value.bitwiseOrThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int16_relaxed(_:_:) + public func bitwiseXorThenLoad_Int16_relaxed( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_xor_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int16" + return value.bitwiseXorThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int16_acquiring(_:_:) + public func bitwiseXorThenLoad_Int16_acquiring( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_xor_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int16" + return value.bitwiseXorThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int16_releasing(_:_:) + public func bitwiseXorThenLoad_Int16_releasing( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_xor_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int16" + return value.bitwiseXorThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int16_acquiringAndReleasing(_:_:) + public func bitwiseXorThenLoad_Int16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_xor_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int16" + return value.bitwiseXorThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int16_sequential(_:_:) + public func bitwiseXorThenLoad_Int16_sequential( + _ value: UnsafeAtomic, + _ operand: Int16 + ) -> Int16 { + // CHECK: builtin "atomicrmw_xor_seqcst_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int16" + return value.bitwiseXorThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int8_relaxed(_:_:) + public func loadThenWrappingIncrement_Int8_relaxed( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_add_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int8" + return value.loadThenWrappingIncrement(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int8_acquiring(_:_:) + public func loadThenWrappingIncrement_Int8_acquiring( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_add_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int8" + return value.loadThenWrappingIncrement(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int8_releasing(_:_:) + public func loadThenWrappingIncrement_Int8_releasing( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_add_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int8" + return value.loadThenWrappingIncrement(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int8_acquiringAndReleasing(_:_:) + public func loadThenWrappingIncrement_Int8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_add_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int8" + return value.loadThenWrappingIncrement( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_Int8_sequential(_:_:) + public func loadThenWrappingIncrement_Int8_sequential( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_add_seqcst_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int8" + return value.loadThenWrappingIncrement( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int8_relaxed(_:_:) + public func loadThenWrappingDecrement_Int8_relaxed( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_sub_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int8" + return value.loadThenWrappingDecrement(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int8_acquiring(_:_:) + public func loadThenWrappingDecrement_Int8_acquiring( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_sub_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int8" + return value.loadThenWrappingDecrement(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int8_releasing(_:_:) + public func loadThenWrappingDecrement_Int8_releasing( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_sub_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int8" + return value.loadThenWrappingDecrement(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int8_acquiringAndReleasing(_:_:) + public func loadThenWrappingDecrement_Int8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_sub_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int8" + return value.loadThenWrappingDecrement( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_Int8_sequential(_:_:) + public func loadThenWrappingDecrement_Int8_sequential( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_sub_seqcst_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int8" + return value.loadThenWrappingDecrement( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int8_relaxed(_:_:) + public func loadThenBitwiseAnd_Int8_relaxed( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_and_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int8" + return value.loadThenBitwiseAnd(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int8_acquiring(_:_:) + public func loadThenBitwiseAnd_Int8_acquiring( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_and_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int8" + return value.loadThenBitwiseAnd(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int8_releasing(_:_:) + public func loadThenBitwiseAnd_Int8_releasing( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_and_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int8" + return value.loadThenBitwiseAnd(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int8_acquiringAndReleasing(_:_:) + public func loadThenBitwiseAnd_Int8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_and_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int8" + return value.loadThenBitwiseAnd( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_Int8_sequential(_:_:) + public func loadThenBitwiseAnd_Int8_sequential( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_and_seqcst_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int8" + return value.loadThenBitwiseAnd( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int8_relaxed(_:_:) + public func loadThenBitwiseOr_Int8_relaxed( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_or_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int8" + return value.loadThenBitwiseOr(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int8_acquiring(_:_:) + public func loadThenBitwiseOr_Int8_acquiring( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_or_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int8" + return value.loadThenBitwiseOr(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int8_releasing(_:_:) + public func loadThenBitwiseOr_Int8_releasing( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_or_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int8" + return value.loadThenBitwiseOr(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int8_acquiringAndReleasing(_:_:) + public func loadThenBitwiseOr_Int8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_or_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int8" + return value.loadThenBitwiseOr( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_Int8_sequential(_:_:) + public func loadThenBitwiseOr_Int8_sequential( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_or_seqcst_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int8" + return value.loadThenBitwiseOr( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int8_relaxed(_:_:) + public func loadThenBitwiseXor_Int8_relaxed( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_xor_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int8" + return value.loadThenBitwiseXor(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int8_acquiring(_:_:) + public func loadThenBitwiseXor_Int8_acquiring( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_xor_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int8" + return value.loadThenBitwiseXor(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int8_releasing(_:_:) + public func loadThenBitwiseXor_Int8_releasing( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_xor_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int8" + return value.loadThenBitwiseXor(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int8_acquiringAndReleasing(_:_:) + public func loadThenBitwiseXor_Int8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_xor_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int8" + return value.loadThenBitwiseXor( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_Int8_sequential(_:_:) + public func loadThenBitwiseXor_Int8_sequential( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_xor_seqcst_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int8" + return value.loadThenBitwiseXor( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int8_relaxed(_:_:) + public func wrappingIncrementThenLoad_Int8_relaxed( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_add_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int8" + return value.wrappingIncrementThenLoad(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int8_acquiring(_:_:) + public func wrappingIncrementThenLoad_Int8_acquiring( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_add_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int8" + return value.wrappingIncrementThenLoad(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int8_releasing(_:_:) + public func wrappingIncrementThenLoad_Int8_releasing( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_add_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int8" + return value.wrappingIncrementThenLoad(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int8_acquiringAndReleasing(_:_:) + public func wrappingIncrementThenLoad_Int8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_add_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int8" + return value.wrappingIncrementThenLoad( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_Int8_sequential(_:_:) + public func wrappingIncrementThenLoad_Int8_sequential( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_add_seqcst_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int8" + return value.wrappingIncrementThenLoad( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int8_relaxed(_:_:) + public func wrappingDecrementThenLoad_Int8_relaxed( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_sub_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int8" + return value.wrappingDecrementThenLoad(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int8_acquiring(_:_:) + public func wrappingDecrementThenLoad_Int8_acquiring( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_sub_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int8" + return value.wrappingDecrementThenLoad(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int8_releasing(_:_:) + public func wrappingDecrementThenLoad_Int8_releasing( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_sub_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int8" + return value.wrappingDecrementThenLoad(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int8_acquiringAndReleasing(_:_:) + public func wrappingDecrementThenLoad_Int8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_sub_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int8" + return value.wrappingDecrementThenLoad( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_Int8_sequential(_:_:) + public func wrappingDecrementThenLoad_Int8_sequential( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_sub_seqcst_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int8" + return value.wrappingDecrementThenLoad( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int8_relaxed(_:_:) + public func bitwiseAndThenLoad_Int8_relaxed( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_and_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int8" + return value.bitwiseAndThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int8_acquiring(_:_:) + public func bitwiseAndThenLoad_Int8_acquiring( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_and_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int8" + return value.bitwiseAndThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int8_releasing(_:_:) + public func bitwiseAndThenLoad_Int8_releasing( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_and_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int8" + return value.bitwiseAndThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int8_acquiringAndReleasing(_:_:) + public func bitwiseAndThenLoad_Int8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_and_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int8" + return value.bitwiseAndThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_Int8_sequential(_:_:) + public func bitwiseAndThenLoad_Int8_sequential( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_and_seqcst_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int8" + return value.bitwiseAndThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int8_relaxed(_:_:) + public func bitwiseOrThenLoad_Int8_relaxed( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_or_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int8" + return value.bitwiseOrThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int8_acquiring(_:_:) + public func bitwiseOrThenLoad_Int8_acquiring( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_or_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int8" + return value.bitwiseOrThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int8_releasing(_:_:) + public func bitwiseOrThenLoad_Int8_releasing( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_or_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int8" + return value.bitwiseOrThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int8_acquiringAndReleasing(_:_:) + public func bitwiseOrThenLoad_Int8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_or_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int8" + return value.bitwiseOrThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_Int8_sequential(_:_:) + public func bitwiseOrThenLoad_Int8_sequential( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_or_seqcst_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int8" + return value.bitwiseOrThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int8_relaxed(_:_:) + public func bitwiseXorThenLoad_Int8_relaxed( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_xor_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int8" + return value.bitwiseXorThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int8_acquiring(_:_:) + public func bitwiseXorThenLoad_Int8_acquiring( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_xor_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int8" + return value.bitwiseXorThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int8_releasing(_:_:) + public func bitwiseXorThenLoad_Int8_releasing( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_xor_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int8" + return value.bitwiseXorThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int8_acquiringAndReleasing(_:_:) + public func bitwiseXorThenLoad_Int8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_xor_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int8" + return value.bitwiseXorThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_Int8_sequential(_:_:) + public func bitwiseXorThenLoad_Int8_sequential( + _ value: UnsafeAtomic, + _ operand: Int8 + ) -> Int8 { + // CHECK: builtin "atomicrmw_xor_seqcst_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int8" + return value.bitwiseXorThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt_relaxed(_:_:) + public func loadThenWrappingIncrement_UInt_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_add_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Word" + return value.loadThenWrappingIncrement(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt_acquiring(_:_:) + public func loadThenWrappingIncrement_UInt_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_add_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Word" + return value.loadThenWrappingIncrement(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt_releasing(_:_:) + public func loadThenWrappingIncrement_UInt_releasing( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_add_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Word" + return value.loadThenWrappingIncrement(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt_acquiringAndReleasing(_:_:) + public func loadThenWrappingIncrement_UInt_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_add_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Word" + return value.loadThenWrappingIncrement( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt_sequential(_:_:) + public func loadThenWrappingIncrement_UInt_sequential( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_add_seqcst_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Word" + return value.loadThenWrappingIncrement( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt_relaxed(_:_:) + public func loadThenWrappingDecrement_UInt_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_sub_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Word" + return value.loadThenWrappingDecrement(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt_acquiring(_:_:) + public func loadThenWrappingDecrement_UInt_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_sub_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Word" + return value.loadThenWrappingDecrement(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt_releasing(_:_:) + public func loadThenWrappingDecrement_UInt_releasing( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_sub_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Word" + return value.loadThenWrappingDecrement(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt_acquiringAndReleasing(_:_:) + public func loadThenWrappingDecrement_UInt_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_sub_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Word" + return value.loadThenWrappingDecrement( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt_sequential(_:_:) + public func loadThenWrappingDecrement_UInt_sequential( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_sub_seqcst_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Word" + return value.loadThenWrappingDecrement( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt_relaxed(_:_:) + public func loadThenBitwiseAnd_UInt_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_and_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Word" + return value.loadThenBitwiseAnd(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt_acquiring(_:_:) + public func loadThenBitwiseAnd_UInt_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_and_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Word" + return value.loadThenBitwiseAnd(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt_releasing(_:_:) + public func loadThenBitwiseAnd_UInt_releasing( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_and_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Word" + return value.loadThenBitwiseAnd(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt_acquiringAndReleasing(_:_:) + public func loadThenBitwiseAnd_UInt_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_and_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Word" + return value.loadThenBitwiseAnd( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt_sequential(_:_:) + public func loadThenBitwiseAnd_UInt_sequential( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_and_seqcst_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Word" + return value.loadThenBitwiseAnd( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt_relaxed(_:_:) + public func loadThenBitwiseOr_UInt_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_or_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Word" + return value.loadThenBitwiseOr(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt_acquiring(_:_:) + public func loadThenBitwiseOr_UInt_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_or_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Word" + return value.loadThenBitwiseOr(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt_releasing(_:_:) + public func loadThenBitwiseOr_UInt_releasing( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_or_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Word" + return value.loadThenBitwiseOr(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt_acquiringAndReleasing(_:_:) + public func loadThenBitwiseOr_UInt_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_or_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Word" + return value.loadThenBitwiseOr( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt_sequential(_:_:) + public func loadThenBitwiseOr_UInt_sequential( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_or_seqcst_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Word" + return value.loadThenBitwiseOr( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt_relaxed(_:_:) + public func loadThenBitwiseXor_UInt_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_xor_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Word" + return value.loadThenBitwiseXor(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt_acquiring(_:_:) + public func loadThenBitwiseXor_UInt_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_xor_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Word" + return value.loadThenBitwiseXor(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt_releasing(_:_:) + public func loadThenBitwiseXor_UInt_releasing( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_xor_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Word" + return value.loadThenBitwiseXor(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt_acquiringAndReleasing(_:_:) + public func loadThenBitwiseXor_UInt_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_xor_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Word" + return value.loadThenBitwiseXor( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt_sequential(_:_:) + public func loadThenBitwiseXor_UInt_sequential( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_xor_seqcst_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Word" + return value.loadThenBitwiseXor( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt_relaxed(_:_:) + public func wrappingIncrementThenLoad_UInt_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_add_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Word" + return value.wrappingIncrementThenLoad(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt_acquiring(_:_:) + public func wrappingIncrementThenLoad_UInt_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_add_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Word" + return value.wrappingIncrementThenLoad(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt_releasing(_:_:) + public func wrappingIncrementThenLoad_UInt_releasing( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_add_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Word" + return value.wrappingIncrementThenLoad(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt_acquiringAndReleasing(_:_:) + public func wrappingIncrementThenLoad_UInt_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_add_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Word" + return value.wrappingIncrementThenLoad( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt_sequential(_:_:) + public func wrappingIncrementThenLoad_UInt_sequential( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_add_seqcst_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Word" + return value.wrappingIncrementThenLoad( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt_relaxed(_:_:) + public func wrappingDecrementThenLoad_UInt_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_sub_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Word" + return value.wrappingDecrementThenLoad(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt_acquiring(_:_:) + public func wrappingDecrementThenLoad_UInt_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_sub_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Word" + return value.wrappingDecrementThenLoad(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt_releasing(_:_:) + public func wrappingDecrementThenLoad_UInt_releasing( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_sub_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Word" + return value.wrappingDecrementThenLoad(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt_acquiringAndReleasing(_:_:) + public func wrappingDecrementThenLoad_UInt_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_sub_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Word" + return value.wrappingDecrementThenLoad( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt_sequential(_:_:) + public func wrappingDecrementThenLoad_UInt_sequential( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_sub_seqcst_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Word" + return value.wrappingDecrementThenLoad( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt_relaxed(_:_:) + public func bitwiseAndThenLoad_UInt_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_and_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Word" + return value.bitwiseAndThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt_acquiring(_:_:) + public func bitwiseAndThenLoad_UInt_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_and_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Word" + return value.bitwiseAndThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt_releasing(_:_:) + public func bitwiseAndThenLoad_UInt_releasing( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_and_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Word" + return value.bitwiseAndThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt_acquiringAndReleasing(_:_:) + public func bitwiseAndThenLoad_UInt_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_and_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Word" + return value.bitwiseAndThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt_sequential(_:_:) + public func bitwiseAndThenLoad_UInt_sequential( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_and_seqcst_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Word" + return value.bitwiseAndThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt_relaxed(_:_:) + public func bitwiseOrThenLoad_UInt_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_or_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Word" + return value.bitwiseOrThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt_acquiring(_:_:) + public func bitwiseOrThenLoad_UInt_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_or_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Word" + return value.bitwiseOrThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt_releasing(_:_:) + public func bitwiseOrThenLoad_UInt_releasing( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_or_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Word" + return value.bitwiseOrThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt_acquiringAndReleasing(_:_:) + public func bitwiseOrThenLoad_UInt_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_or_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Word" + return value.bitwiseOrThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt_sequential(_:_:) + public func bitwiseOrThenLoad_UInt_sequential( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_or_seqcst_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Word" + return value.bitwiseOrThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt_relaxed(_:_:) + public func bitwiseXorThenLoad_UInt_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_xor_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Word" + return value.bitwiseXorThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt_acquiring(_:_:) + public func bitwiseXorThenLoad_UInt_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_xor_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Word" + return value.bitwiseXorThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt_releasing(_:_:) + public func bitwiseXorThenLoad_UInt_releasing( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_xor_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Word" + return value.bitwiseXorThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt_acquiringAndReleasing(_:_:) + public func bitwiseXorThenLoad_UInt_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_xor_acqrel_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Word" + return value.bitwiseXorThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt_sequential(_:_:) + public func bitwiseXorThenLoad_UInt_sequential( + _ value: UnsafeAtomic, + _ operand: UInt + ) -> UInt { + // CHECK: builtin "atomicrmw_xor_seqcst_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Word" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Word" + return value.bitwiseXorThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt64_relaxed(_:_:) + public func loadThenWrappingIncrement_UInt64_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_add_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int64" + return value.loadThenWrappingIncrement(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt64_acquiring(_:_:) + public func loadThenWrappingIncrement_UInt64_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_add_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int64" + return value.loadThenWrappingIncrement(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt64_releasing(_:_:) + public func loadThenWrappingIncrement_UInt64_releasing( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_add_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int64" + return value.loadThenWrappingIncrement(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt64_acquiringAndReleasing(_:_:) + public func loadThenWrappingIncrement_UInt64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_add_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int64" + return value.loadThenWrappingIncrement( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt64_sequential(_:_:) + public func loadThenWrappingIncrement_UInt64_sequential( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_add_seqcst_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int64" + return value.loadThenWrappingIncrement( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt64_relaxed(_:_:) + public func loadThenWrappingDecrement_UInt64_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_sub_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int64" + return value.loadThenWrappingDecrement(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt64_acquiring(_:_:) + public func loadThenWrappingDecrement_UInt64_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_sub_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int64" + return value.loadThenWrappingDecrement(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt64_releasing(_:_:) + public func loadThenWrappingDecrement_UInt64_releasing( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_sub_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int64" + return value.loadThenWrappingDecrement(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt64_acquiringAndReleasing(_:_:) + public func loadThenWrappingDecrement_UInt64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_sub_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int64" + return value.loadThenWrappingDecrement( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt64_sequential(_:_:) + public func loadThenWrappingDecrement_UInt64_sequential( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_sub_seqcst_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int64" + return value.loadThenWrappingDecrement( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt64_relaxed(_:_:) + public func loadThenBitwiseAnd_UInt64_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_and_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int64" + return value.loadThenBitwiseAnd(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt64_acquiring(_:_:) + public func loadThenBitwiseAnd_UInt64_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_and_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int64" + return value.loadThenBitwiseAnd(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt64_releasing(_:_:) + public func loadThenBitwiseAnd_UInt64_releasing( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_and_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int64" + return value.loadThenBitwiseAnd(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt64_acquiringAndReleasing(_:_:) + public func loadThenBitwiseAnd_UInt64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_and_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int64" + return value.loadThenBitwiseAnd( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt64_sequential(_:_:) + public func loadThenBitwiseAnd_UInt64_sequential( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_and_seqcst_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int64" + return value.loadThenBitwiseAnd( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt64_relaxed(_:_:) + public func loadThenBitwiseOr_UInt64_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_or_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int64" + return value.loadThenBitwiseOr(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt64_acquiring(_:_:) + public func loadThenBitwiseOr_UInt64_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_or_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int64" + return value.loadThenBitwiseOr(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt64_releasing(_:_:) + public func loadThenBitwiseOr_UInt64_releasing( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_or_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int64" + return value.loadThenBitwiseOr(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt64_acquiringAndReleasing(_:_:) + public func loadThenBitwiseOr_UInt64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_or_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int64" + return value.loadThenBitwiseOr( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt64_sequential(_:_:) + public func loadThenBitwiseOr_UInt64_sequential( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_or_seqcst_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int64" + return value.loadThenBitwiseOr( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt64_relaxed(_:_:) + public func loadThenBitwiseXor_UInt64_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_xor_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int64" + return value.loadThenBitwiseXor(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt64_acquiring(_:_:) + public func loadThenBitwiseXor_UInt64_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_xor_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int64" + return value.loadThenBitwiseXor(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt64_releasing(_:_:) + public func loadThenBitwiseXor_UInt64_releasing( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_xor_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int64" + return value.loadThenBitwiseXor(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt64_acquiringAndReleasing(_:_:) + public func loadThenBitwiseXor_UInt64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_xor_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int64" + return value.loadThenBitwiseXor( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt64_sequential(_:_:) + public func loadThenBitwiseXor_UInt64_sequential( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_xor_seqcst_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int64" + return value.loadThenBitwiseXor( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt64_relaxed(_:_:) + public func wrappingIncrementThenLoad_UInt64_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_add_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int64" + return value.wrappingIncrementThenLoad(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt64_acquiring(_:_:) + public func wrappingIncrementThenLoad_UInt64_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_add_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int64" + return value.wrappingIncrementThenLoad(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt64_releasing(_:_:) + public func wrappingIncrementThenLoad_UInt64_releasing( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_add_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int64" + return value.wrappingIncrementThenLoad(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt64_acquiringAndReleasing(_:_:) + public func wrappingIncrementThenLoad_UInt64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_add_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int64" + return value.wrappingIncrementThenLoad( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt64_sequential(_:_:) + public func wrappingIncrementThenLoad_UInt64_sequential( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_add_seqcst_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int64" + return value.wrappingIncrementThenLoad( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt64_relaxed(_:_:) + public func wrappingDecrementThenLoad_UInt64_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_sub_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int64" + return value.wrappingDecrementThenLoad(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt64_acquiring(_:_:) + public func wrappingDecrementThenLoad_UInt64_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_sub_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int64" + return value.wrappingDecrementThenLoad(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt64_releasing(_:_:) + public func wrappingDecrementThenLoad_UInt64_releasing( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_sub_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int64" + return value.wrappingDecrementThenLoad(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt64_acquiringAndReleasing(_:_:) + public func wrappingDecrementThenLoad_UInt64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_sub_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int64" + return value.wrappingDecrementThenLoad( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt64_sequential(_:_:) + public func wrappingDecrementThenLoad_UInt64_sequential( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_sub_seqcst_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int64" + return value.wrappingDecrementThenLoad( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt64_relaxed(_:_:) + public func bitwiseAndThenLoad_UInt64_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_and_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int64" + return value.bitwiseAndThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt64_acquiring(_:_:) + public func bitwiseAndThenLoad_UInt64_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_and_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int64" + return value.bitwiseAndThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt64_releasing(_:_:) + public func bitwiseAndThenLoad_UInt64_releasing( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_and_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int64" + return value.bitwiseAndThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt64_acquiringAndReleasing(_:_:) + public func bitwiseAndThenLoad_UInt64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_and_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int64" + return value.bitwiseAndThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt64_sequential(_:_:) + public func bitwiseAndThenLoad_UInt64_sequential( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_and_seqcst_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int64" + return value.bitwiseAndThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt64_relaxed(_:_:) + public func bitwiseOrThenLoad_UInt64_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_or_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int64" + return value.bitwiseOrThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt64_acquiring(_:_:) + public func bitwiseOrThenLoad_UInt64_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_or_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int64" + return value.bitwiseOrThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt64_releasing(_:_:) + public func bitwiseOrThenLoad_UInt64_releasing( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_or_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int64" + return value.bitwiseOrThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt64_acquiringAndReleasing(_:_:) + public func bitwiseOrThenLoad_UInt64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_or_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int64" + return value.bitwiseOrThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt64_sequential(_:_:) + public func bitwiseOrThenLoad_UInt64_sequential( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_or_seqcst_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int64" + return value.bitwiseOrThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt64_relaxed(_:_:) + public func bitwiseXorThenLoad_UInt64_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_xor_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int64" + return value.bitwiseXorThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt64_acquiring(_:_:) + public func bitwiseXorThenLoad_UInt64_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_xor_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int64" + return value.bitwiseXorThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt64_releasing(_:_:) + public func bitwiseXorThenLoad_UInt64_releasing( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_xor_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int64" + return value.bitwiseXorThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt64_acquiringAndReleasing(_:_:) + public func bitwiseXorThenLoad_UInt64_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_xor_acqrel_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int64" + return value.bitwiseXorThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt64_sequential(_:_:) + public func bitwiseXorThenLoad_UInt64_sequential( + _ value: UnsafeAtomic, + _ operand: UInt64 + ) -> UInt64 { + // CHECK: builtin "atomicrmw_xor_seqcst_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int64" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int64" + return value.bitwiseXorThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt32_relaxed(_:_:) + public func loadThenWrappingIncrement_UInt32_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_add_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int32" + return value.loadThenWrappingIncrement(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt32_acquiring(_:_:) + public func loadThenWrappingIncrement_UInt32_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_add_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int32" + return value.loadThenWrappingIncrement(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt32_releasing(_:_:) + public func loadThenWrappingIncrement_UInt32_releasing( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_add_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int32" + return value.loadThenWrappingIncrement(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt32_acquiringAndReleasing(_:_:) + public func loadThenWrappingIncrement_UInt32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_add_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int32" + return value.loadThenWrappingIncrement( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt32_sequential(_:_:) + public func loadThenWrappingIncrement_UInt32_sequential( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_add_seqcst_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int32" + return value.loadThenWrappingIncrement( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt32_relaxed(_:_:) + public func loadThenWrappingDecrement_UInt32_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_sub_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int32" + return value.loadThenWrappingDecrement(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt32_acquiring(_:_:) + public func loadThenWrappingDecrement_UInt32_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_sub_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int32" + return value.loadThenWrappingDecrement(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt32_releasing(_:_:) + public func loadThenWrappingDecrement_UInt32_releasing( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_sub_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int32" + return value.loadThenWrappingDecrement(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt32_acquiringAndReleasing(_:_:) + public func loadThenWrappingDecrement_UInt32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_sub_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int32" + return value.loadThenWrappingDecrement( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt32_sequential(_:_:) + public func loadThenWrappingDecrement_UInt32_sequential( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_sub_seqcst_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int32" + return value.loadThenWrappingDecrement( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt32_relaxed(_:_:) + public func loadThenBitwiseAnd_UInt32_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_and_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int32" + return value.loadThenBitwiseAnd(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt32_acquiring(_:_:) + public func loadThenBitwiseAnd_UInt32_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_and_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int32" + return value.loadThenBitwiseAnd(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt32_releasing(_:_:) + public func loadThenBitwiseAnd_UInt32_releasing( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_and_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int32" + return value.loadThenBitwiseAnd(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt32_acquiringAndReleasing(_:_:) + public func loadThenBitwiseAnd_UInt32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_and_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int32" + return value.loadThenBitwiseAnd( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt32_sequential(_:_:) + public func loadThenBitwiseAnd_UInt32_sequential( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_and_seqcst_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int32" + return value.loadThenBitwiseAnd( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt32_relaxed(_:_:) + public func loadThenBitwiseOr_UInt32_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_or_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int32" + return value.loadThenBitwiseOr(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt32_acquiring(_:_:) + public func loadThenBitwiseOr_UInt32_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_or_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int32" + return value.loadThenBitwiseOr(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt32_releasing(_:_:) + public func loadThenBitwiseOr_UInt32_releasing( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_or_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int32" + return value.loadThenBitwiseOr(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt32_acquiringAndReleasing(_:_:) + public func loadThenBitwiseOr_UInt32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_or_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int32" + return value.loadThenBitwiseOr( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt32_sequential(_:_:) + public func loadThenBitwiseOr_UInt32_sequential( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_or_seqcst_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int32" + return value.loadThenBitwiseOr( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt32_relaxed(_:_:) + public func loadThenBitwiseXor_UInt32_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_xor_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int32" + return value.loadThenBitwiseXor(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt32_acquiring(_:_:) + public func loadThenBitwiseXor_UInt32_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_xor_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int32" + return value.loadThenBitwiseXor(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt32_releasing(_:_:) + public func loadThenBitwiseXor_UInt32_releasing( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_xor_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int32" + return value.loadThenBitwiseXor(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt32_acquiringAndReleasing(_:_:) + public func loadThenBitwiseXor_UInt32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_xor_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int32" + return value.loadThenBitwiseXor( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt32_sequential(_:_:) + public func loadThenBitwiseXor_UInt32_sequential( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_xor_seqcst_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int32" + return value.loadThenBitwiseXor( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt32_relaxed(_:_:) + public func wrappingIncrementThenLoad_UInt32_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_add_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int32" + return value.wrappingIncrementThenLoad(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt32_acquiring(_:_:) + public func wrappingIncrementThenLoad_UInt32_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_add_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int32" + return value.wrappingIncrementThenLoad(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt32_releasing(_:_:) + public func wrappingIncrementThenLoad_UInt32_releasing( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_add_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int32" + return value.wrappingIncrementThenLoad(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt32_acquiringAndReleasing(_:_:) + public func wrappingIncrementThenLoad_UInt32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_add_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int32" + return value.wrappingIncrementThenLoad( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt32_sequential(_:_:) + public func wrappingIncrementThenLoad_UInt32_sequential( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_add_seqcst_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int32" + return value.wrappingIncrementThenLoad( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt32_relaxed(_:_:) + public func wrappingDecrementThenLoad_UInt32_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_sub_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int32" + return value.wrappingDecrementThenLoad(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt32_acquiring(_:_:) + public func wrappingDecrementThenLoad_UInt32_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_sub_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int32" + return value.wrappingDecrementThenLoad(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt32_releasing(_:_:) + public func wrappingDecrementThenLoad_UInt32_releasing( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_sub_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int32" + return value.wrappingDecrementThenLoad(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt32_acquiringAndReleasing(_:_:) + public func wrappingDecrementThenLoad_UInt32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_sub_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int32" + return value.wrappingDecrementThenLoad( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt32_sequential(_:_:) + public func wrappingDecrementThenLoad_UInt32_sequential( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_sub_seqcst_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int32" + return value.wrappingDecrementThenLoad( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt32_relaxed(_:_:) + public func bitwiseAndThenLoad_UInt32_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_and_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int32" + return value.bitwiseAndThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt32_acquiring(_:_:) + public func bitwiseAndThenLoad_UInt32_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_and_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int32" + return value.bitwiseAndThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt32_releasing(_:_:) + public func bitwiseAndThenLoad_UInt32_releasing( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_and_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int32" + return value.bitwiseAndThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt32_acquiringAndReleasing(_:_:) + public func bitwiseAndThenLoad_UInt32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_and_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int32" + return value.bitwiseAndThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt32_sequential(_:_:) + public func bitwiseAndThenLoad_UInt32_sequential( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_and_seqcst_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int32" + return value.bitwiseAndThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt32_relaxed(_:_:) + public func bitwiseOrThenLoad_UInt32_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_or_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int32" + return value.bitwiseOrThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt32_acquiring(_:_:) + public func bitwiseOrThenLoad_UInt32_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_or_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int32" + return value.bitwiseOrThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt32_releasing(_:_:) + public func bitwiseOrThenLoad_UInt32_releasing( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_or_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int32" + return value.bitwiseOrThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt32_acquiringAndReleasing(_:_:) + public func bitwiseOrThenLoad_UInt32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_or_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int32" + return value.bitwiseOrThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt32_sequential(_:_:) + public func bitwiseOrThenLoad_UInt32_sequential( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_or_seqcst_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int32" + return value.bitwiseOrThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt32_relaxed(_:_:) + public func bitwiseXorThenLoad_UInt32_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_xor_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int32" + return value.bitwiseXorThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt32_acquiring(_:_:) + public func bitwiseXorThenLoad_UInt32_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_xor_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int32" + return value.bitwiseXorThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt32_releasing(_:_:) + public func bitwiseXorThenLoad_UInt32_releasing( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_xor_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int32" + return value.bitwiseXorThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt32_acquiringAndReleasing(_:_:) + public func bitwiseXorThenLoad_UInt32_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_xor_acqrel_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int32" + return value.bitwiseXorThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt32_sequential(_:_:) + public func bitwiseXorThenLoad_UInt32_sequential( + _ value: UnsafeAtomic, + _ operand: UInt32 + ) -> UInt32 { + // CHECK: builtin "atomicrmw_xor_seqcst_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int32" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int32" + return value.bitwiseXorThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt16_relaxed(_:_:) + public func loadThenWrappingIncrement_UInt16_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_add_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int16" + return value.loadThenWrappingIncrement(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt16_acquiring(_:_:) + public func loadThenWrappingIncrement_UInt16_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_add_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int16" + return value.loadThenWrappingIncrement(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt16_releasing(_:_:) + public func loadThenWrappingIncrement_UInt16_releasing( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_add_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int16" + return value.loadThenWrappingIncrement(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt16_acquiringAndReleasing(_:_:) + public func loadThenWrappingIncrement_UInt16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_add_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int16" + return value.loadThenWrappingIncrement( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt16_sequential(_:_:) + public func loadThenWrappingIncrement_UInt16_sequential( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_add_seqcst_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int16" + return value.loadThenWrappingIncrement( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt16_relaxed(_:_:) + public func loadThenWrappingDecrement_UInt16_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_sub_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int16" + return value.loadThenWrappingDecrement(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt16_acquiring(_:_:) + public func loadThenWrappingDecrement_UInt16_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_sub_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int16" + return value.loadThenWrappingDecrement(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt16_releasing(_:_:) + public func loadThenWrappingDecrement_UInt16_releasing( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_sub_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int16" + return value.loadThenWrappingDecrement(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt16_acquiringAndReleasing(_:_:) + public func loadThenWrappingDecrement_UInt16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_sub_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int16" + return value.loadThenWrappingDecrement( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt16_sequential(_:_:) + public func loadThenWrappingDecrement_UInt16_sequential( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_sub_seqcst_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int16" + return value.loadThenWrappingDecrement( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt16_relaxed(_:_:) + public func loadThenBitwiseAnd_UInt16_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_and_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int16" + return value.loadThenBitwiseAnd(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt16_acquiring(_:_:) + public func loadThenBitwiseAnd_UInt16_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_and_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int16" + return value.loadThenBitwiseAnd(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt16_releasing(_:_:) + public func loadThenBitwiseAnd_UInt16_releasing( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_and_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int16" + return value.loadThenBitwiseAnd(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt16_acquiringAndReleasing(_:_:) + public func loadThenBitwiseAnd_UInt16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_and_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int16" + return value.loadThenBitwiseAnd( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt16_sequential(_:_:) + public func loadThenBitwiseAnd_UInt16_sequential( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_and_seqcst_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int16" + return value.loadThenBitwiseAnd( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt16_relaxed(_:_:) + public func loadThenBitwiseOr_UInt16_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_or_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int16" + return value.loadThenBitwiseOr(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt16_acquiring(_:_:) + public func loadThenBitwiseOr_UInt16_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_or_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int16" + return value.loadThenBitwiseOr(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt16_releasing(_:_:) + public func loadThenBitwiseOr_UInt16_releasing( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_or_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int16" + return value.loadThenBitwiseOr(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt16_acquiringAndReleasing(_:_:) + public func loadThenBitwiseOr_UInt16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_or_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int16" + return value.loadThenBitwiseOr( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt16_sequential(_:_:) + public func loadThenBitwiseOr_UInt16_sequential( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_or_seqcst_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int16" + return value.loadThenBitwiseOr( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt16_relaxed(_:_:) + public func loadThenBitwiseXor_UInt16_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_xor_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int16" + return value.loadThenBitwiseXor(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt16_acquiring(_:_:) + public func loadThenBitwiseXor_UInt16_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_xor_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int16" + return value.loadThenBitwiseXor(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt16_releasing(_:_:) + public func loadThenBitwiseXor_UInt16_releasing( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_xor_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int16" + return value.loadThenBitwiseXor(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt16_acquiringAndReleasing(_:_:) + public func loadThenBitwiseXor_UInt16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_xor_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int16" + return value.loadThenBitwiseXor( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt16_sequential(_:_:) + public func loadThenBitwiseXor_UInt16_sequential( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_xor_seqcst_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int16" + return value.loadThenBitwiseXor( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt16_relaxed(_:_:) + public func wrappingIncrementThenLoad_UInt16_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_add_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int16" + return value.wrappingIncrementThenLoad(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt16_acquiring(_:_:) + public func wrappingIncrementThenLoad_UInt16_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_add_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int16" + return value.wrappingIncrementThenLoad(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt16_releasing(_:_:) + public func wrappingIncrementThenLoad_UInt16_releasing( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_add_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int16" + return value.wrappingIncrementThenLoad(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt16_acquiringAndReleasing(_:_:) + public func wrappingIncrementThenLoad_UInt16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_add_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int16" + return value.wrappingIncrementThenLoad( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt16_sequential(_:_:) + public func wrappingIncrementThenLoad_UInt16_sequential( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_add_seqcst_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int16" + return value.wrappingIncrementThenLoad( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt16_relaxed(_:_:) + public func wrappingDecrementThenLoad_UInt16_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_sub_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int16" + return value.wrappingDecrementThenLoad(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt16_acquiring(_:_:) + public func wrappingDecrementThenLoad_UInt16_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_sub_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int16" + return value.wrappingDecrementThenLoad(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt16_releasing(_:_:) + public func wrappingDecrementThenLoad_UInt16_releasing( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_sub_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int16" + return value.wrappingDecrementThenLoad(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt16_acquiringAndReleasing(_:_:) + public func wrappingDecrementThenLoad_UInt16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_sub_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int16" + return value.wrappingDecrementThenLoad( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt16_sequential(_:_:) + public func wrappingDecrementThenLoad_UInt16_sequential( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_sub_seqcst_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int16" + return value.wrappingDecrementThenLoad( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt16_relaxed(_:_:) + public func bitwiseAndThenLoad_UInt16_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_and_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int16" + return value.bitwiseAndThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt16_acquiring(_:_:) + public func bitwiseAndThenLoad_UInt16_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_and_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int16" + return value.bitwiseAndThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt16_releasing(_:_:) + public func bitwiseAndThenLoad_UInt16_releasing( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_and_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int16" + return value.bitwiseAndThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt16_acquiringAndReleasing(_:_:) + public func bitwiseAndThenLoad_UInt16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_and_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int16" + return value.bitwiseAndThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt16_sequential(_:_:) + public func bitwiseAndThenLoad_UInt16_sequential( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_and_seqcst_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int16" + return value.bitwiseAndThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt16_relaxed(_:_:) + public func bitwiseOrThenLoad_UInt16_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_or_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int16" + return value.bitwiseOrThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt16_acquiring(_:_:) + public func bitwiseOrThenLoad_UInt16_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_or_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int16" + return value.bitwiseOrThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt16_releasing(_:_:) + public func bitwiseOrThenLoad_UInt16_releasing( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_or_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int16" + return value.bitwiseOrThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt16_acquiringAndReleasing(_:_:) + public func bitwiseOrThenLoad_UInt16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_or_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int16" + return value.bitwiseOrThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt16_sequential(_:_:) + public func bitwiseOrThenLoad_UInt16_sequential( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_or_seqcst_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int16" + return value.bitwiseOrThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt16_relaxed(_:_:) + public func bitwiseXorThenLoad_UInt16_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_xor_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int16" + return value.bitwiseXorThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt16_acquiring(_:_:) + public func bitwiseXorThenLoad_UInt16_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_xor_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int16" + return value.bitwiseXorThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt16_releasing(_:_:) + public func bitwiseXorThenLoad_UInt16_releasing( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_xor_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int16" + return value.bitwiseXorThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt16_acquiringAndReleasing(_:_:) + public func bitwiseXorThenLoad_UInt16_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_xor_acqrel_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int16" + return value.bitwiseXorThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt16_sequential(_:_:) + public func bitwiseXorThenLoad_UInt16_sequential( + _ value: UnsafeAtomic, + _ operand: UInt16 + ) -> UInt16 { + // CHECK: builtin "atomicrmw_xor_seqcst_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int16" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int16" + return value.bitwiseXorThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt8_relaxed(_:_:) + public func loadThenWrappingIncrement_UInt8_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_add_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int8" + return value.loadThenWrappingIncrement(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt8_acquiring(_:_:) + public func loadThenWrappingIncrement_UInt8_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_add_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int8" + return value.loadThenWrappingIncrement(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt8_releasing(_:_:) + public func loadThenWrappingIncrement_UInt8_releasing( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_add_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int8" + return value.loadThenWrappingIncrement(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt8_acquiringAndReleasing(_:_:) + public func loadThenWrappingIncrement_UInt8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_add_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int8" + return value.loadThenWrappingIncrement( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingIncrement_UInt8_sequential(_:_:) + public func loadThenWrappingIncrement_UInt8_sequential( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_add_seqcst_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int8" + return value.loadThenWrappingIncrement( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt8_relaxed(_:_:) + public func loadThenWrappingDecrement_UInt8_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_sub_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int8" + return value.loadThenWrappingDecrement(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt8_acquiring(_:_:) + public func loadThenWrappingDecrement_UInt8_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_sub_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int8" + return value.loadThenWrappingDecrement(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt8_releasing(_:_:) + public func loadThenWrappingDecrement_UInt8_releasing( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_sub_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int8" + return value.loadThenWrappingDecrement(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt8_acquiringAndReleasing(_:_:) + public func loadThenWrappingDecrement_UInt8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_sub_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int8" + return value.loadThenWrappingDecrement( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenWrappingDecrement_UInt8_sequential(_:_:) + public func loadThenWrappingDecrement_UInt8_sequential( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_sub_seqcst_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int8" + return value.loadThenWrappingDecrement( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt8_relaxed(_:_:) + public func loadThenBitwiseAnd_UInt8_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_and_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int8" + return value.loadThenBitwiseAnd(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt8_acquiring(_:_:) + public func loadThenBitwiseAnd_UInt8_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_and_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int8" + return value.loadThenBitwiseAnd(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt8_releasing(_:_:) + public func loadThenBitwiseAnd_UInt8_releasing( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_and_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int8" + return value.loadThenBitwiseAnd(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt8_acquiringAndReleasing(_:_:) + public func loadThenBitwiseAnd_UInt8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_and_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int8" + return value.loadThenBitwiseAnd( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseAnd_UInt8_sequential(_:_:) + public func loadThenBitwiseAnd_UInt8_sequential( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_and_seqcst_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int8" + return value.loadThenBitwiseAnd( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt8_relaxed(_:_:) + public func loadThenBitwiseOr_UInt8_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_or_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int8" + return value.loadThenBitwiseOr(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt8_acquiring(_:_:) + public func loadThenBitwiseOr_UInt8_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_or_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int8" + return value.loadThenBitwiseOr(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt8_releasing(_:_:) + public func loadThenBitwiseOr_UInt8_releasing( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_or_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int8" + return value.loadThenBitwiseOr(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt8_acquiringAndReleasing(_:_:) + public func loadThenBitwiseOr_UInt8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_or_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int8" + return value.loadThenBitwiseOr( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseOr_UInt8_sequential(_:_:) + public func loadThenBitwiseOr_UInt8_sequential( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_or_seqcst_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int8" + return value.loadThenBitwiseOr( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt8_relaxed(_:_:) + public func loadThenBitwiseXor_UInt8_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_xor_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int8" + return value.loadThenBitwiseXor(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt8_acquiring(_:_:) + public func loadThenBitwiseXor_UInt8_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_xor_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int8" + return value.loadThenBitwiseXor(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt8_releasing(_:_:) + public func loadThenBitwiseXor_UInt8_releasing( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_xor_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int8" + return value.loadThenBitwiseXor(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt8_acquiringAndReleasing(_:_:) + public func loadThenBitwiseXor_UInt8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_xor_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int8" + return value.loadThenBitwiseXor( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.loadThenBitwiseXor_UInt8_sequential(_:_:) + public func loadThenBitwiseXor_UInt8_sequential( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_xor_seqcst_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int8" + return value.loadThenBitwiseXor( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt8_relaxed(_:_:) + public func wrappingIncrementThenLoad_UInt8_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_add_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int8" + return value.wrappingIncrementThenLoad(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt8_acquiring(_:_:) + public func wrappingIncrementThenLoad_UInt8_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_add_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int8" + return value.wrappingIncrementThenLoad(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt8_releasing(_:_:) + public func wrappingIncrementThenLoad_UInt8_releasing( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_add_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int8" + return value.wrappingIncrementThenLoad(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt8_acquiringAndReleasing(_:_:) + public func wrappingIncrementThenLoad_UInt8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_add_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_seqcst_Int8" + return value.wrappingIncrementThenLoad( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingIncrementThenLoad_UInt8_sequential(_:_:) + public func wrappingIncrementThenLoad_UInt8_sequential( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_add_seqcst_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_add_acqrel_Int8" + return value.wrappingIncrementThenLoad( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt8_relaxed(_:_:) + public func wrappingDecrementThenLoad_UInt8_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_sub_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int8" + return value.wrappingDecrementThenLoad(by: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt8_acquiring(_:_:) + public func wrappingDecrementThenLoad_UInt8_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_sub_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int8" + return value.wrappingDecrementThenLoad(by: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt8_releasing(_:_:) + public func wrappingDecrementThenLoad_UInt8_releasing( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_sub_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int8" + return value.wrappingDecrementThenLoad(by: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt8_acquiringAndReleasing(_:_:) + public func wrappingDecrementThenLoad_UInt8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_sub_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_seqcst_Int8" + return value.wrappingDecrementThenLoad( + by: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.wrappingDecrementThenLoad_UInt8_sequential(_:_:) + public func wrappingDecrementThenLoad_UInt8_sequential( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_sub_seqcst_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_sub_acqrel_Int8" + return value.wrappingDecrementThenLoad( + by: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt8_relaxed(_:_:) + public func bitwiseAndThenLoad_UInt8_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_and_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int8" + return value.bitwiseAndThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt8_acquiring(_:_:) + public func bitwiseAndThenLoad_UInt8_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_and_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int8" + return value.bitwiseAndThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt8_releasing(_:_:) + public func bitwiseAndThenLoad_UInt8_releasing( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_and_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int8" + return value.bitwiseAndThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt8_acquiringAndReleasing(_:_:) + public func bitwiseAndThenLoad_UInt8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_and_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_seqcst_Int8" + return value.bitwiseAndThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseAndThenLoad_UInt8_sequential(_:_:) + public func bitwiseAndThenLoad_UInt8_sequential( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_and_seqcst_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_and_acqrel_Int8" + return value.bitwiseAndThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt8_relaxed(_:_:) + public func bitwiseOrThenLoad_UInt8_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_or_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int8" + return value.bitwiseOrThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt8_acquiring(_:_:) + public func bitwiseOrThenLoad_UInt8_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_or_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int8" + return value.bitwiseOrThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt8_releasing(_:_:) + public func bitwiseOrThenLoad_UInt8_releasing( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_or_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int8" + return value.bitwiseOrThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt8_acquiringAndReleasing(_:_:) + public func bitwiseOrThenLoad_UInt8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_or_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_seqcst_Int8" + return value.bitwiseOrThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseOrThenLoad_UInt8_sequential(_:_:) + public func bitwiseOrThenLoad_UInt8_sequential( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_or_seqcst_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_or_acqrel_Int8" + return value.bitwiseOrThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt8_relaxed(_:_:) + public func bitwiseXorThenLoad_UInt8_relaxed( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_xor_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int8" + return value.bitwiseXorThenLoad(with: operand, ordering: .relaxed) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt8_acquiring(_:_:) + public func bitwiseXorThenLoad_UInt8_acquiring( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_xor_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int8" + return value.bitwiseXorThenLoad(with: operand, ordering: .acquiring) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt8_releasing(_:_:) + public func bitwiseXorThenLoad_UInt8_releasing( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_xor_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int8" + return value.bitwiseXorThenLoad(with: operand, ordering: .releasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt8_acquiringAndReleasing(_:_:) + public func bitwiseXorThenLoad_UInt8_acquiringAndReleasing( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_xor_acqrel_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_seqcst_Int8" + return value.bitwiseXorThenLoad( + with: operand, + ordering: .acquiringAndReleasing) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // SECTIONING-LABEL: // AtomicFoldingTests.bitwiseXorThenLoad_UInt8_sequential(_:_:) + public func bitwiseXorThenLoad_UInt8_sequential( + _ value: UnsafeAtomic, + _ operand: UInt8 + ) -> UInt8 { + // CHECK: builtin "atomicrmw_xor_seqcst_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_monotonic_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acquire_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_release_Int8" + // EXCLUSIONS-NOT: builtin "atomicrmw_xor_acqrel_Int8" + return value.bitwiseXorThenLoad( + with: operand, + ordering: .sequentiallyConsistent) + } + // SECTIONING-LABEL: } // end sil function '$s14AtomicsFolding + + // --------------------------------------------------------------------------- +} diff --git a/Tests/lit/autogenerated/UnsafeAtomicInitializers.swift b/Tests/lit/autogenerated/UnsafeAtomicInitializers.swift new file mode 100644 index 0000000..aaa38b4 --- /dev/null +++ b/Tests/lit/autogenerated/UnsafeAtomicInitializers.swift @@ -0,0 +1,276 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the Swift Atomics 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 +// +//===----------------------------------------------------------------------===// +// RUN: %empty-directory(%t) +// RUN: %gyb %s -o %t/UnsafeAtomicInitializers.swift +// RUN: %line-directive %t/UnsafeAtomicInitializers.swift -- %target-swift-frontend -typecheck -verify %t/UnsafeAtomicInitializers.swift + + +// ############################################################################# +// # # +// # DO NOT EDIT THIS FILE; IT IS AUTOGENERATED. # +// # # +// ############################################################################# + + +import Atomics + +class Foo { + var value = 0 +} +struct Bar { + var value = 0 +} + +func test_Int() -> UnsafeAtomic { + var storage = UnsafeAtomic.Storage(0) + let atomic = UnsafeAtomic(at: &storage) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomic.Storage' to 'UnsafeMutablePointer.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + return atomic +} +func test_Int64() -> UnsafeAtomic { + var storage = UnsafeAtomic.Storage(0) + let atomic = UnsafeAtomic(at: &storage) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomic.Storage' to 'UnsafeMutablePointer.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + return atomic +} +func test_Int32() -> UnsafeAtomic { + var storage = UnsafeAtomic.Storage(0) + let atomic = UnsafeAtomic(at: &storage) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomic.Storage' to 'UnsafeMutablePointer.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + return atomic +} +func test_Int16() -> UnsafeAtomic { + var storage = UnsafeAtomic.Storage(0) + let atomic = UnsafeAtomic(at: &storage) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomic.Storage' to 'UnsafeMutablePointer.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + return atomic +} +func test_Int8() -> UnsafeAtomic { + var storage = UnsafeAtomic.Storage(0) + let atomic = UnsafeAtomic(at: &storage) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomic.Storage' to 'UnsafeMutablePointer.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + return atomic +} +func test_UInt() -> UnsafeAtomic { + var storage = UnsafeAtomic.Storage(0) + let atomic = UnsafeAtomic(at: &storage) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomic.Storage' to 'UnsafeMutablePointer.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + return atomic +} +func test_UInt64() -> UnsafeAtomic { + var storage = UnsafeAtomic.Storage(0) + let atomic = UnsafeAtomic(at: &storage) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomic.Storage' to 'UnsafeMutablePointer.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + return atomic +} +func test_UInt32() -> UnsafeAtomic { + var storage = UnsafeAtomic.Storage(0) + let atomic = UnsafeAtomic(at: &storage) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomic.Storage' to 'UnsafeMutablePointer.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + return atomic +} +func test_UInt16() -> UnsafeAtomic { + var storage = UnsafeAtomic.Storage(0) + let atomic = UnsafeAtomic(at: &storage) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomic.Storage' to 'UnsafeMutablePointer.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + return atomic +} +func test_UInt8() -> UnsafeAtomic { + var storage = UnsafeAtomic.Storage(0) + let atomic = UnsafeAtomic(at: &storage) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomic.Storage' to 'UnsafeMutablePointer.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + return atomic +} +func test_URP() -> UnsafeAtomic { + var storage = UnsafeAtomic.Storage(UnsafeRawPointer(UnsafeMutableRawPointer.allocate(byteCount: 8, alignment: 8))) + let atomic = UnsafeAtomic(at: &storage) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomic.Storage' to 'UnsafeMutablePointer.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + return atomic +} +func test_UP() -> UnsafeAtomic> { + var storage = UnsafeAtomic>.Storage(UnsafePointer(UnsafeMutablePointer.allocate(capacity: 1))) + let atomic = UnsafeAtomic>(at: &storage) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomic>.Storage' to 'UnsafeMutablePointer>.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + return atomic +} +func test_UMRP() -> UnsafeAtomic { + var storage = UnsafeAtomic.Storage(.allocate(byteCount: 8, alignment: 8)) + let atomic = UnsafeAtomic(at: &storage) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomic.Storage' to 'UnsafeMutablePointer.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + return atomic +} +func test_UMP() -> UnsafeAtomic> { + var storage = UnsafeAtomic>.Storage(.allocate(capacity: 1)) + let atomic = UnsafeAtomic>(at: &storage) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomic>.Storage' to 'UnsafeMutablePointer>.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + return atomic +} +func test_Unmanaged() -> UnsafeAtomic> { + var storage = UnsafeAtomic>.Storage(Unmanaged.passRetained(Foo())) + let atomic = UnsafeAtomic>(at: &storage) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomic>.Storage' to 'UnsafeMutablePointer>.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + return atomic +} +func test_URPOpt() -> UnsafeAtomic { + var storage = UnsafeAtomic.Storage(nil) + let atomic = UnsafeAtomic(at: &storage) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomic.Storage' to 'UnsafeMutablePointer.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + return atomic +} +func test_UPOpt() -> UnsafeAtomic?> { + var storage = UnsafeAtomic?>.Storage(nil) + let atomic = UnsafeAtomic?>(at: &storage) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomic?>.Storage' to 'UnsafeMutablePointer?>.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + return atomic +} +func test_UMRPOpt() -> UnsafeAtomic { + var storage = UnsafeAtomic.Storage(nil) + let atomic = UnsafeAtomic(at: &storage) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomic.Storage' to 'UnsafeMutablePointer.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + return atomic +} +func test_UMPOpt() -> UnsafeAtomic?> { + var storage = UnsafeAtomic?>.Storage(nil) + let atomic = UnsafeAtomic?>(at: &storage) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomic?>.Storage' to 'UnsafeMutablePointer?>.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + return atomic +} +func test_UnmanagedOpt() -> UnsafeAtomic?> { + var storage = UnsafeAtomic?>.Storage(nil) + let atomic = UnsafeAtomic?>(at: &storage) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomic?>.Storage' to 'UnsafeMutablePointer?>.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + return atomic +} + +func test_UnsafeAtomicLazyReference() -> UnsafeAtomicLazyReference { + var value = UnsafeAtomicLazyReference.Storage() + let atomic = UnsafeAtomicLazyReference(at: &value) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomicLazyReference.Storage' to 'UnsafeMutablePointer.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + return atomic +} + +class BrokenAtomicCounter { // THIS IS BROKEN; DO NOT USE + private var _storage = UnsafeAtomic.Storage(0) + private var _value: UnsafeAtomic? + + init() { + // This escapes the ephemeral pointer generated by the inout expression, + // so it leads to undefined behavior when the pointer gets dereferenced + // in the atomic operations below. DO NOT DO THIS. + _value = UnsafeAtomic(at: &_storage) // expected-warning {{inout expression creates a temporary pointer, but argument 'at' should be a pointer that outlives the call to 'init(at:)'}} + // expected-note@-1 {{implicit argument conversion from 'UnsafeAtomic.Storage' to 'UnsafeMutablePointer.Storage>' produces a pointer valid only for the duration of the call to 'init(at:)'}} + // expected-note@-2 {{use 'withUnsafeMutablePointer' in order to explicitly convert argument to pointer valid for a defined scope}} + } + + func increment() { + _value!.wrappingIncrement(by: 1, ordering: .relaxed) + } + + func get() -> Int { + _value!.load(ordering: .relaxed) + } +} + +struct AtomicCounter { + typealias Value = Int + typealias Header = UnsafeAtomic.Storage + + class Buffer: ManagedBuffer { + deinit { + withUnsafeMutablePointerToHeader { header in + _ = header.pointee.dispose() + } + } + } + + let buffer: Buffer + + init() { + buffer = Buffer.create(minimumCapacity: 0) { _ in + Header(0) + } as! Buffer + } + + private func _withAtomicPointer( + _ body: (UnsafeAtomic) throws -> R + ) rethrows -> R { + try buffer.withUnsafeMutablePointerToHeader { header in + try body(UnsafeAtomic(at: header)) + } + } + + func increment() { + _withAtomicPointer { $0.wrappingIncrement(ordering: .relaxed) } + } + + func load() -> Int { + _withAtomicPointer { $0.load(ordering: .relaxed) } + } +} + +struct AtomicUnmanagedRef { + typealias Value = Unmanaged? + typealias Header = UnsafeAtomic.Storage + + class Buffer: ManagedBuffer { + deinit { + withUnsafeMutablePointerToHeader { header in + _ = header.pointee.dispose() + } + } + } + + let buffer: Buffer + + init() { + buffer = Buffer.create(minimumCapacity: 0) { _ in + Header(nil) + } as! Buffer + } + + private func _withAtomicPointer( + _ body: (UnsafeAtomic) throws -> R + ) rethrows -> R { + try buffer.withUnsafeMutablePointerToHeader { header in + try body(UnsafeAtomic(at: header)) + } + } + + func store(_ desired: Value) { + _withAtomicPointer { $0.store(desired, ordering: .sequentiallyConsistent) } + } + + func load() -> Value { + _withAtomicPointer { $0.load(ordering: .sequentiallyConsistent) } + } +} diff --git a/Utilities/gyb b/Utilities/gyb new file mode 100755 index 0000000..dece788 --- /dev/null +++ b/Utilities/gyb @@ -0,0 +1,3 @@ +#!/usr/bin/env python2.7 +import gyb +gyb.main() diff --git a/Utilities/gyb.py b/Utilities/gyb.py new file mode 100755 index 0000000..2df9a03 --- /dev/null +++ b/Utilities/gyb.py @@ -0,0 +1,1260 @@ +#!/usr/bin/env python +# GYB: Generate Your Boilerplate (improved names welcome; at least +# this one's short). See -h output for instructions + +from __future__ import print_function + +import os +import re +import sys +import textwrap +import tokenize +from bisect import bisect + + +try: + from cStringIO import StringIO +except ImportError: + from io import StringIO + + +try: + basestring +except NameError: + basestring = str + + +def get_line_starts(s): + """Return a list containing the start index of each line in s. + + The list also contains a sentinel index for the end of the string, + so there will be one more element in the list than there are lines + in the string + """ + starts = [0] + + for line in s.split('\n'): + starts.append(starts[-1] + len(line) + 1) + + starts[-1] -= 1 + return starts + + +def strip_trailing_nl(s): + """If s ends with a newline, drop it; else return s intact""" + return s[:-1] if s.endswith('\n') else s + + +def split_lines(s): + """Split s into a list of lines, each of which has a trailing newline + + If the lines are later concatenated, the result is s, possibly + with a single appended newline. + """ + return [l + '\n' for l in s.split('\n')] + + +# text on a line up to the first '$$', '${', or '%%' +literalText = r'(?: [^$\n%] | \$(?![${]) | %(?!%) )*' + +# The part of an '%end' line that follows the '%' sign +linesClose = r'[\ \t]* end [\ \t]* (?: \# .* )? $' + +# Note: Where "# Absorb" appears below, the regexp attempts to eat up +# through the end of ${...} and %{...}% constructs. In reality we +# handle this with the Python tokenizer, which avoids mis-detections +# due to nesting, comments and strings. This extra absorption in the +# regexp facilitates testing the regexp on its own, by preventing the +# interior of some of these constructs from being treated as literal +# text. +tokenize_re = re.compile( + r''' +# %-lines and %{...}-blocks + # \n? # absorb one preceding newline + ^ + (?: + (?P + (?P<_indent> [\ \t]* % (?! [{%] ) [\ \t]* ) (?! [\ \t] | ''' + + linesClose + r''' ) .* + ( \n (?P=_indent) (?! ''' + linesClose + r''' ) .* ) * + ) + | (?P [\ \t]* % [ \t]* ''' + linesClose + r''' ) + | [\ \t]* (?P %\{ ) + (?: [^}]| \} (?!%) )* \}% # Absorb + ) + \n? # absorb one trailing newline + +# Substitutions +| (?P \$\{ ) + [^}]* \} # Absorb + +# %% and $$ are literal % and $ respectively +| (?P[$%]) (?P=symbol) + +# Literal text +| (?P ''' + literalText + r''' + (?: + # newline that doesn't precede space+% + (?: \n (?! [\ \t]* %[^%] ) ) + ''' + literalText + r''' + )* + \n? + ) +''', re.VERBOSE | re.MULTILINE) + +gyb_block_close = re.compile(r'\}%[ \t]*\n?') + + +def token_pos_to_index(token_pos, start, line_starts): + """Translate a tokenize (line, column) pair into an absolute + position in source text given the position where we started + tokenizing and a list that maps lines onto their starting + character indexes. + """ + relative_token_line_plus1, token_col = token_pos + + # line number where we started tokenizing + start_line_num = bisect(line_starts, start) - 1 + + # line number of the token in the whole text + abs_token_line = relative_token_line_plus1 - 1 + start_line_num + + # if found in the first line, adjust the end column to account + # for the extra text + if relative_token_line_plus1 == 1: + token_col += start - line_starts[start_line_num] + + # Sometimes tokenizer errors report a line beyond the last one + if abs_token_line >= len(line_starts): + return line_starts[-1] + + return line_starts[abs_token_line] + token_col + + +def tokenize_python_to_unmatched_close_curly(source_text, start, line_starts): + """Apply Python's tokenize to source_text starting at index start + while matching open and close curly braces. When an unmatched + close curly brace is found, return its index. If not found, + return len(source_text). If there's a tokenization error, return + the position of the error. + """ + stream = StringIO(source_text) + stream.seek(start) + nesting = 0 + + try: + for kind, text, token_start, token_end, line_text \ + in tokenize.generate_tokens(stream.readline): + + if text == '{': + nesting += 1 + elif text == '}': + nesting -= 1 + if nesting < 0: + return token_pos_to_index(token_start, start, line_starts) + + except tokenize.TokenError as error: + (message, error_pos) = error.args + return token_pos_to_index(error_pos, start, line_starts) + + return len(source_text) + + +def tokenize_template(template_text): + r"""Given the text of a template, returns an iterator over + (tokenType, token, match) tuples. + + **Note**: this is template syntax tokenization, not Python + tokenization. + + When a non-literal token is matched, a client may call + iter.send(pos) on the iterator to reset the position in + template_text at which scanning will resume. + + This function provides a base level of tokenization which is + then refined by ParseContext.token_generator. + + >>> from pprint import * + >>> pprint(list((kind, text) for kind, text, _ in tokenize_template( + ... '%for x in range(10):\n% print x\n%end\njuicebox'))) + [('gybLines', '%for x in range(10):\n% print x'), + ('gybLinesClose', '%end'), + ('literal', 'juicebox')] + + >>> pprint(list((kind, text) for kind, text, _ in tokenize_template( + ... '''Nothing + ... % if x: + ... % for i in range(3): + ... ${i} + ... % end + ... % else: + ... THIS SHOULD NOT APPEAR IN THE OUTPUT + ... '''))) + [('literal', 'Nothing\n'), + ('gybLines', '% if x:\n% for i in range(3):'), + ('substitutionOpen', '${'), + ('literal', '\n'), + ('gybLinesClose', '% end'), + ('gybLines', '% else:'), + ('literal', 'THIS SHOULD NOT APPEAR IN THE OUTPUT\n')] + + >>> for kind, text, _ in tokenize_template(''' + ... This is $some$ literal stuff containing a ${substitution} + ... followed by a %{...} block: + ... %{ + ... # Python code + ... }% + ... and here $${are} some %-lines: + ... % x = 1 + ... % y = 2 + ... % if z == 3: + ... % print '${hello}' + ... % end + ... % for x in zz: + ... % print x + ... % # different indentation + ... % twice + ... and some lines that literally start with a %% token + ... %% first line + ... %% second line + ... '''): + ... print((kind, text.strip().split('\n',1)[0])) + ('literal', 'This is $some$ literal stuff containing a') + ('substitutionOpen', '${') + ('literal', 'followed by a %{...} block:') + ('gybBlockOpen', '%{') + ('literal', 'and here ${are} some %-lines:') + ('gybLines', '% x = 1') + ('gybLinesClose', '% end') + ('gybLines', '% for x in zz:') + ('gybLines', '% # different indentation') + ('gybLines', '% twice') + ('literal', 'and some lines that literally start with a % token') + """ + pos = 0 + end = len(template_text) + + saved_literal = [] + literal_first_match = None + + while pos < end: + m = tokenize_re.match(template_text, pos, end) + + # pull out the one matched key (ignoring internal patterns starting + # with _) + ((kind, text), ) = ( + (kind, text) for (kind, text) in m.groupdict().items() + if text is not None and kind[0] != '_') + + if kind in ('literal', 'symbol'): + if len(saved_literal) == 0: + literal_first_match = m + # literals and symbols get batched together + saved_literal.append(text) + pos = None + else: + # found a non-literal. First yield any literal we've accumulated + if saved_literal != []: + yield 'literal', ''.join(saved_literal), literal_first_match + saved_literal = [] + + # Then yield the thing we found. If we get a reply, it's + # the place to resume tokenizing + pos = yield kind, text, m + + # If we were not sent a new position by our client, resume + # tokenizing at the end of this match. + if pos is None: + pos = m.end(0) + else: + # Client is not yet ready to process next token + yield + + if saved_literal != []: + yield 'literal', ''.join(saved_literal), literal_first_match + + +def split_gyb_lines(source_lines): + r"""Return a list of lines at which to split the incoming source + + These positions represent the beginnings of python line groups that + will require a matching %end construct if they are to be closed. + + >>> src = split_lines('''\ + ... if x: + ... print x + ... if y: # trailing comment + ... print z + ... if z: # another comment\ + ... ''') + >>> s = split_gyb_lines(src) + >>> len(s) + 2 + >>> src[s[0]] + ' print z\n' + >>> s[1] - len(src) + 0 + + >>> src = split_lines('''\ + ... if x: + ... if y: print 1 + ... if z: + ... print 2 + ... pass\ + ... ''') + >>> s = split_gyb_lines(src) + >>> len(s) + 1 + >>> src[s[0]] + ' if y: print 1\n' + + >>> src = split_lines('''\ + ... if x: + ... if y: + ... print 1 + ... print 2 + ... ''') + >>> s = split_gyb_lines(src) + >>> len(s) + 2 + >>> src[s[0]] + ' if y:\n' + >>> src[s[1]] + ' print 1\n' + """ + last_token_text, last_token_kind = None, None + unmatched_indents = [] + + dedents = 0 + try: + for token_kind, token_text, token_start, \ + (token_end_line, token_end_col), line_text \ + in tokenize.generate_tokens(lambda i=iter(source_lines): + next(i)): + + if token_kind in (tokenize.COMMENT, tokenize.ENDMARKER): + continue + + if token_text == '\n' and last_token_text == ':': + unmatched_indents.append(token_end_line) + + # The tokenizer appends dedents at EOF; don't consider + # those as matching indentations. Instead just save them + # up... + if last_token_kind == tokenize.DEDENT: + dedents += 1 + # And count them later, when we see something real. + if token_kind != tokenize.DEDENT and dedents > 0: + unmatched_indents = unmatched_indents[:-dedents] + dedents = 0 + + last_token_text, last_token_kind = token_text, token_kind + + except tokenize.TokenError: + # Let the later compile() call report the error + return [] + + if last_token_text == ':': + unmatched_indents.append(len(source_lines)) + + return unmatched_indents + + +def code_starts_with_dedent_keyword(source_lines): + r"""Return True iff the incoming Python source_lines begin with "else", + "elif", "except", or "finally". + + Initial comments and whitespace are ignored. + + >>> code_starts_with_dedent_keyword(split_lines('if x in y: pass')) + False + >>> code_starts_with_dedent_keyword(split_lines('except ifSomethingElse:')) + True + >>> code_starts_with_dedent_keyword( + ... split_lines('\n# comment\nelse: # yes')) + True + """ + token_text = None + for token_kind, token_text, _, _, _ \ + in tokenize.generate_tokens(lambda i=iter(source_lines): next(i)): + + if token_kind != tokenize.COMMENT and token_text.strip() != '': + break + + return token_text in ('else', 'elif', 'except', 'finally') + + +class ParseContext(object): + + """State carried through a parse of a template""" + + filename = '' + template = '' + line_starts = [] + code_start_line = -1 + code_text = None + tokens = None # The rest of the tokens + close_lines = False + + def __init__(self, filename, template=None): + self.filename = os.path.abspath(filename) + if sys.platform == 'win32': + self.filename = self.filename.replace('\\', '/') + if template is None: + with open(filename) as f: + self.template = f.read() + else: + self.template = template + self.line_starts = get_line_starts(self.template) + self.tokens = self.token_generator(tokenize_template(self.template)) + self.next_token() + + def pos_to_line(self, pos): + return bisect(self.line_starts, pos) - 1 + + def token_generator(self, base_tokens): + r"""Given an iterator over (kind, text, match) triples (see + tokenize_template above), return a refined iterator over + token_kinds. + + Among other adjustments to the elements found by base_tokens, + this refined iterator tokenizes python code embedded in + template text to help determine its true extent. The + expression "base_tokens.send(pos)" is used to reset the index at + which base_tokens resumes scanning the underlying text. + + >>> ctx = ParseContext('dummy', ''' + ... %for x in y: + ... % print x + ... % end + ... literally + ... ''') + >>> while ctx.token_kind: + ... print((ctx.token_kind, ctx.code_text or ctx.token_text)) + ... ignored = ctx.next_token() + ('literal', '\n') + ('gybLinesOpen', 'for x in y:\n') + ('gybLines', ' print x\n') + ('gybLinesClose', '% end') + ('literal', 'literally\n') + + >>> ctx = ParseContext('dummy', + ... '''Nothing + ... % if x: + ... % for i in range(3): + ... ${i} + ... % end + ... % else: + ... THIS SHOULD NOT APPEAR IN THE OUTPUT + ... ''') + >>> while ctx.token_kind: + ... print((ctx.token_kind, ctx.code_text or ctx.token_text)) + ... ignored = ctx.next_token() + ('literal', 'Nothing\n') + ('gybLinesOpen', 'if x:\n') + ('gybLinesOpen', ' for i in range(3):\n') + ('substitutionOpen', 'i') + ('literal', '\n') + ('gybLinesClose', '% end') + ('gybLinesOpen', 'else:\n') + ('literal', 'THIS SHOULD NOT APPEAR IN THE OUTPUT\n') + + >>> ctx = ParseContext('dummy', + ... '''% for x in [1, 2, 3]: + ... % if x == 1: + ... literal1 + ... % elif x > 1: # add output line here to fix bug + ... % if x == 2: + ... literal2 + ... % end + ... % end + ... % end + ... ''') + >>> while ctx.token_kind: + ... print((ctx.token_kind, ctx.code_text or ctx.token_text)) + ... ignored = ctx.next_token() + ('gybLinesOpen', 'for x in [1, 2, 3]:\n') + ('gybLinesOpen', ' if x == 1:\n') + ('literal', 'literal1\n') + ('gybLinesOpen', 'elif x > 1: # add output line here to fix bug\n') + ('gybLinesOpen', ' if x == 2:\n') + ('literal', 'literal2\n') + ('gybLinesClose', '% end') + ('gybLinesClose', '% end') + ('gybLinesClose', '% end') + """ + for self.token_kind, self.token_text, self.token_match in base_tokens: + kind = self.token_kind + self.code_text = None + + # Do we need to close the current lines? + self.close_lines = kind == 'gybLinesClose' + + # %{...}% and ${...} constructs + if kind.endswith('Open'): + + # Tokenize text that follows as Python up to an unmatched '}' + code_start = self.token_match.end(kind) + self.code_start_line = self.pos_to_line(code_start) + + close_pos = tokenize_python_to_unmatched_close_curly( + self.template, code_start, self.line_starts) + self.code_text = self.template[code_start:close_pos] + yield kind + + if (kind == 'gybBlockOpen'): + # Absorb any '}% \n' + m2 = gyb_block_close.match(self.template, close_pos) + if not m2: + raise ValueError("Invalid block closure") + next_pos = m2.end(0) + else: + assert kind == 'substitutionOpen' + # skip past the closing '}' + next_pos = close_pos + 1 + + # Resume tokenizing after the end of the code. + base_tokens.send(next_pos) + + elif kind == 'gybLines': + + self.code_start_line = self.pos_to_line( + self.token_match.start('gybLines')) + indentation = self.token_match.group('_indent') + + # Strip off the leading indentation and %-sign + source_lines = re.split( + '^' + re.escape(indentation), + self.token_match.group('gybLines') + '\n', + flags=re.MULTILINE)[1:] + + if code_starts_with_dedent_keyword(source_lines): + self.close_lines = True + + last_split = 0 + for line in split_gyb_lines(source_lines): + self.token_kind = 'gybLinesOpen' + self.code_text = ''.join(source_lines[last_split:line]) + yield self.token_kind + last_split = line + self.code_start_line += line - last_split + self.close_lines = False + + self.code_text = ''.join(source_lines[last_split:]) + if self.code_text: + self.token_kind = 'gybLines' + yield self.token_kind + else: + yield self.token_kind + + def next_token(self): + """Move to the next token""" + for kind in self.tokens: + return self.token_kind + + self.token_kind = None + + +_default_line_directive = \ + '// ###sourceLocation(file: "%(file)s", line: %(line)d)' + + +class ExecutionContext(object): + + """State we pass around during execution of a template""" + + def __init__(self, line_directive=_default_line_directive, + **local_bindings): + self.local_bindings = local_bindings + self.line_directive = line_directive + self.local_bindings['__context__'] = self + self.result_text = [] + self.last_file_line = None + + def append_text(self, text, file, line): + # see if we need to inject a line marker + if self.line_directive: + if (file, line) != self.last_file_line: + # We can only insert the line directive at a line break + if len(self.result_text) == 0 \ + or self.result_text[-1].endswith('\n'): + substitutions = {'file': file, 'line': line + 1} + format_str = self.line_directive + '\n' + self.result_text.append(format_str % substitutions) + # But if the new text contains any line breaks, we can create + # one + elif '\n' in text: + i = text.find('\n') + self.result_text.append(text[:i + 1]) + # and try again + self.append_text(text[i + 1:], file, line + 1) + return + + self.result_text.append(text) + self.last_file_line = (file, line + text.count('\n')) + + +class ASTNode(object): + + """Abstract base class for template AST nodes""" + + def __init__(self): + raise NotImplementedError("ASTNode.__init__ is not implemented.") + + def execute(self, context): + raise NotImplementedError("ASTNode.execute is not implemented.") + + def __str__(self, indent=''): + raise NotImplementedError("ASTNode.__str__ is not implemented.") + + def format_children(self, indent): + if not self.children: + return ' []' + + return '\n'.join( + ['', indent + '['] + + [x.__str__(indent + 4 * ' ') for x in self.children] + + [indent + ']']) + + +class Block(ASTNode): + + """A sequence of other AST nodes, to be executed in order""" + + children = [] + + def __init__(self, context): + self.children = [] + + while context.token_kind and not context.close_lines: + if context.token_kind == 'literal': + node = Literal + else: + node = Code + self.children.append(node(context)) + + def execute(self, context): + for x in self.children: + x.execute(context) + + def __str__(self, indent=''): + return indent + 'Block:' + self.format_children(indent) + + +class Literal(ASTNode): + + """An AST node that generates literal text""" + + def __init__(self, context): + self.text = context.token_text + start_position = context.token_match.start(context.token_kind) + self.start_line_number = context.pos_to_line(start_position) + self.filename = context.filename + context.next_token() + + def execute(self, context): + context.append_text(self.text, self.filename, self.start_line_number) + + def __str__(self, indent=''): + return '\n'.join( + [indent + x for x in ['Literal:'] + + strip_trailing_nl(self.text).split('\n')]) + + +class Code(ASTNode): + + """An AST node that is evaluated as Python""" + + code = None + children = () + kind = None + + def __init__(self, context): + + source = '' + source_line_count = 0 + + def accumulate_code(): + s = source + (context.code_start_line - source_line_count) * '\n' \ + + textwrap.dedent(context.code_text) + line_count = context.code_start_line + \ + context.code_text.count('\n') + context.next_token() + return s, line_count + + eval_exec = 'exec' + if context.token_kind.startswith('substitution'): + eval_exec = 'eval' + source, source_line_count = accumulate_code() + source = '(' + source.strip() + ')' + + else: + while context.token_kind == 'gybLinesOpen': + source, source_line_count = accumulate_code() + source += ' __children__[%d].execute(__context__)\n' % len( + self.children) + source_line_count += 1 + + self.children += (Block(context),) + + if context.token_kind == 'gybLinesClose': + context.next_token() + + if context.token_kind == 'gybLines': + source, source_line_count = accumulate_code() + + # Only handle a substitution as part of this code block if + # we don't already have some %-lines. + elif context.token_kind == 'gybBlockOpen': + + # Opening ${...} and %{...}% constructs + source, source_line_count = accumulate_code() + + self.filename = context.filename + self.start_line_number = context.code_start_line + self.code = compile(source, context.filename, eval_exec) + self.source = source + + def execute(self, context): + # Save __children__ from the local bindings + save_children = context.local_bindings.get('__children__') + # Execute the code with our __children__ in scope + context.local_bindings['__children__'] = self.children + context.local_bindings['__file__'] = self.filename + result = eval(self.code, context.local_bindings) + + if context.local_bindings['__children__'] is not self.children: + raise ValueError("The code is not allowed to mutate __children__") + # Restore the bindings + context.local_bindings['__children__'] = save_children + + # If we got a result, the code was an expression, so append + # its value + if result is not None \ + or (isinstance(result, basestring) and result != ''): + from numbers import Number, Integral + result_string = None + if isinstance(result, Number) and not isinstance(result, Integral): + result_string = repr(result) + else: + result_string = str(result) + context.append_text( + result_string, self.filename, self.start_line_number) + + def __str__(self, indent=''): + source_lines = re.sub(r'^\n', '', strip_trailing_nl( + self.source), flags=re.MULTILINE).split('\n') + if len(source_lines) == 1: + s = indent + 'Code: {' + source_lines[0] + '}' + else: + s = indent + 'Code:\n' + indent + '{\n' + '\n'.join( + indent + 4 * ' ' + l for l in source_lines + ) + '\n' + indent + '}' + return s + self.format_children(indent) + + +def expand(filename, line_directive=_default_line_directive, **local_bindings): + r"""Return the contents of the given template file, executed with the given + local bindings. + + >>> from tempfile import NamedTemporaryFile + >>> # On Windows, the name of a NamedTemporaryFile cannot be used to open + >>> # the file for a second time if delete=True. Therefore, we have to + >>> # manually handle closing and deleting this file to allow us to open + >>> # the file by its name across all platforms. + >>> f = NamedTemporaryFile(delete=False) + >>> f.write( + ... r'''--- + ... % for i in range(int(x)): + ... a pox on ${i} for epoxy + ... % end + ... ${120 + + ... + ... 3} + ... abc + ... ${"w\nx\nX\ny"} + ... z + ... ''') + >>> f.flush() + >>> result = expand( + ... f.name, + ... line_directive='//#sourceLocation(file: "%(file)s", ' + \ + ... 'line: %(line)d)', + ... x=2 + ... ).replace( + ... '"%s"' % f.name.replace('\\', '/'), '"dummy.file"') + >>> print(result, end='') + //#sourceLocation(file: "dummy.file", line: 1) + --- + //#sourceLocation(file: "dummy.file", line: 3) + a pox on 0 for epoxy + //#sourceLocation(file: "dummy.file", line: 3) + a pox on 1 for epoxy + //#sourceLocation(file: "dummy.file", line: 5) + 123 + //#sourceLocation(file: "dummy.file", line: 8) + abc + w + x + X + y + //#sourceLocation(file: "dummy.file", line: 10) + z + >>> f.close() + >>> os.remove(f.name) + """ + with open(filename) as f: + t = parse_template(filename, f.read()) + d = os.getcwd() + os.chdir(os.path.dirname(os.path.abspath(filename))) + try: + return execute_template( + t, line_directive=line_directive, **local_bindings) + finally: + os.chdir(d) + + +def parse_template(filename, text=None): + r"""Return an AST corresponding to the given template file. + + If text is supplied, it is assumed to be the contents of the file, + as a string. + + >>> print(parse_template('dummy.file', text= + ... '''% for x in [1, 2, 3]: + ... % if x == 1: + ... literal1 + ... % elif x > 1: # add output line after this line to fix bug + ... % if x == 2: + ... literal2 + ... % end + ... % end + ... % end + ... ''')) + Block: + [ + Code: + { + for x in [1, 2, 3]: + __children__[0].execute(__context__) + } + [ + Block: + [ + Code: + { + if x == 1: + __children__[0].execute(__context__) + elif x > 1: # add output line after this line to fix bug + __children__[1].execute(__context__) + } + [ + Block: + [ + Literal: + literal1 + ] + Block: + [ + Code: + { + if x == 2: + __children__[0].execute(__context__) + } + [ + Block: + [ + Literal: + literal2 + ] + ] + ] + ] + ] + ] + ] + + >>> print(parse_template( + ... 'dummy.file', + ... text='%for x in range(10):\n% print(x)\n%end\njuicebox')) + Block: + [ + Code: + { + for x in range(10): + __children__[0].execute(__context__) + } + [ + Block: + [ + Code: {print(x)} [] + ] + ] + Literal: + juicebox + ] + + >>> print(parse_template('/dummy.file', text= + ... '''Nothing + ... % if x: + ... % for i in range(3): + ... ${i} + ... % end + ... % else: + ... THIS SHOULD NOT APPEAR IN THE OUTPUT + ... ''')) + Block: + [ + Literal: + Nothing + Code: + { + if x: + __children__[0].execute(__context__) + else: + __children__[1].execute(__context__) + } + [ + Block: + [ + Code: + { + for i in range(3): + __children__[0].execute(__context__) + } + [ + Block: + [ + Code: {(i)} [] + Literal: + + ] + ] + ] + Block: + [ + Literal: + THIS SHOULD NOT APPEAR IN THE OUTPUT + ] + ] + ] + + >>> print(parse_template('dummy.file', text='''% + ... %for x in y: + ... % print(y) + ... ''')) + Block: + [ + Code: + { + for x in y: + __children__[0].execute(__context__) + } + [ + Block: + [ + Code: {print(y)} [] + ] + ] + ] + + >>> print(parse_template('dummy.file', text='''% + ... %if x: + ... % print(y) + ... AAAA + ... %else: + ... BBBB + ... ''')) + Block: + [ + Code: + { + if x: + __children__[0].execute(__context__) + else: + __children__[1].execute(__context__) + } + [ + Block: + [ + Code: {print(y)} [] + Literal: + AAAA + ] + Block: + [ + Literal: + BBBB + ] + ] + ] + + >>> print(parse_template('dummy.file', text='''% + ... %if x: + ... % print(y) + ... AAAA + ... %# This is a comment + ... %else: + ... BBBB + ... ''')) + Block: + [ + Code: + { + if x: + __children__[0].execute(__context__) + # This is a comment + else: + __children__[1].execute(__context__) + } + [ + Block: + [ + Code: {print(y)} [] + Literal: + AAAA + ] + Block: + [ + Literal: + BBBB + ] + ] + ] + + >>> print(parse_template('dummy.file', text='''\ + ... %for x in y: + ... AAAA + ... %if x: + ... BBBB + ... %end + ... CCCC + ... ''')) + Block: + [ + Code: + { + for x in y: + __children__[0].execute(__context__) + } + [ + Block: + [ + Literal: + AAAA + Code: + { + if x: + __children__[0].execute(__context__) + } + [ + Block: + [ + Literal: + BBBB + ] + ] + Literal: + CCCC + ] + ] + ] + """ + return Block(ParseContext(filename, text)) + + +def execute_template( + ast, line_directive=_default_line_directive, **local_bindings): + r"""Return the text generated by executing the given template AST. + + Keyword arguments become local variable bindings in the execution context + + >>> root_directory = os.path.abspath('/') + >>> file_name = (root_directory + 'dummy.file').replace('\\', '/') + >>> ast = parse_template(file_name, text= + ... '''Nothing + ... % if x: + ... % for i in range(3): + ... ${i} + ... % end + ... % else: + ... THIS SHOULD NOT APPEAR IN THE OUTPUT + ... ''') + >>> out = execute_template(ast, + ... line_directive='//#sourceLocation(file: "%(file)s", line: %(line)d)', + ... x=1) + >>> out = out.replace(file_name, "DUMMY-FILE") + >>> print(out, end="") + //#sourceLocation(file: "DUMMY-FILE", line: 1) + Nothing + //#sourceLocation(file: "DUMMY-FILE", line: 4) + 0 + //#sourceLocation(file: "DUMMY-FILE", line: 4) + 1 + //#sourceLocation(file: "DUMMY-FILE", line: 4) + 2 + + >>> ast = parse_template(file_name, text= + ... '''Nothing + ... % a = [] + ... % for x in range(3): + ... % a.append(x) + ... % end + ... ${a} + ... ''') + >>> out = execute_template(ast, + ... line_directive='//#sourceLocation(file: "%(file)s", line: %(line)d)', + ... x=1) + >>> out = out.replace(file_name, "DUMMY-FILE") + >>> print(out, end="") + //#sourceLocation(file: "DUMMY-FILE", line: 1) + Nothing + //#sourceLocation(file: "DUMMY-FILE", line: 6) + [0, 1, 2] + + >>> ast = parse_template(file_name, text= + ... '''Nothing + ... % a = [] + ... % for x in range(3): + ... % a.append(x) + ... % end + ... ${a} + ... ''') + >>> out = execute_template(ast, + ... line_directive='#line %(line)d "%(file)s"', x=1) + >>> out = out.replace(file_name, "DUMMY-FILE") + >>> print(out, end="") + #line 1 "DUMMY-FILE" + Nothing + #line 6 "DUMMY-FILE" + [0, 1, 2] + """ + execution_context = ExecutionContext( + line_directive=line_directive, **local_bindings) + ast.execute(execution_context) + return ''.join(execution_context.result_text) + + +def main(): + import argparse + import sys + + parser = argparse.ArgumentParser( + formatter_class=argparse.RawDescriptionHelpFormatter, + description='Generate Your Boilerplate!', epilog=''' + A GYB template consists of the following elements: + + - Literal text which is inserted directly into the output + + - %% or $$ in literal text, which insert literal '%' and '$' + symbols respectively. + + - Substitutions of the form ${}. The Python + expression is converted to a string and the result is inserted + into the output. + + - Python code delimited by %{...}%. Typically used to inject + definitions (functions, classes, variable bindings) into the + evaluation context of the template. Common indentation is + stripped, so you can add as much indentation to the beginning + of this code as you like + + - Lines beginning with optional whitespace followed by a single + '%' and Python code. %-lines allow you to nest other + constructs inside them. To close a level of nesting, use the + "%end" construct. + + - Lines beginning with optional whitespace and followed by a + single '%' and the token "end", which close open constructs in + %-lines. + + Example template: + + - Hello - + %{ + x = 42 + def succ(a): + return a+1 + }% + + I can assure you that ${x} < ${succ(x)} + + % if int(y) > 7: + % for i in range(3): + y is greater than seven! + % end + % else: + y is less than or equal to seven + % end + + - The End. - + + When run with "gyb -Dy=9", the output is + + - Hello - + + I can assure you that 42 < 43 + + y is greater than seven! + y is greater than seven! + y is greater than seven! + + - The End. - +''' + ) + parser.add_argument( + '-D', action='append', dest='defines', metavar='NAME=VALUE', + default=[], + help='''Bindings to be set in the template's execution context''') + + parser.add_argument( + 'file', type=argparse.FileType(), + help='Path to GYB template file (defaults to stdin)', nargs='?', + default=sys.stdin) + parser.add_argument( + '-o', dest='target', type=argparse.FileType('w'), + help='Output file (defaults to stdout)', default=sys.stdout) + parser.add_argument( + '--test', action='store_true', + default=False, help='Run a self-test') + parser.add_argument( + '--verbose-test', action='store_true', + default=False, help='Run a verbose self-test') + parser.add_argument( + '--dump', action='store_true', + default=False, help='Dump the parsed template to stdout') + parser.add_argument( + '--line-directive', + default=_default_line_directive, + help=''' + Line directive format string, which will be + provided 2 substitutions, `%%(line)d` and `%%(file)s`. + + Example: `#sourceLocation(file: "%%(file)s", line: %%(line)d)` + + The default works automatically with the `line-directive` tool, + which see for more information. + ''') + + args = parser.parse_args(sys.argv[1:]) + + if args.test or args.verbose_test: + import doctest + selfmod = sys.modules[__name__] + if doctest.testmod(selfmod, verbose=args.verbose_test or None).failed: + sys.exit(1) + + bindings = dict(x.split('=', 1) for x in args.defines) + ast = parse_template(args.file.name, args.file.read()) + if args.dump: + print(ast) + # Allow the template to open files and import .py files relative to its own + # directory + os.chdir(os.path.dirname(os.path.abspath(args.file.name))) + sys.path = ['.'] + sys.path + + args.target.write(execute_template(ast, args.line_directive, **bindings)) + + +if __name__ == '__main__': + main() diff --git a/Utilities/gyb_utils.py b/Utilities/gyb_utils.py new file mode 100644 index 0000000..00ccbae --- /dev/null +++ b/Utilities/gyb_utils.py @@ -0,0 +1,85 @@ +#===-----------------------------------------------------------------------===// +# +# 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 autogenerated_warning(): + return """ +// ############################################################################# +// # # +// # DO NOT EDIT THIS FILE; IT IS AUTOGENERATED. # +// # # +// ############################################################################# +""" + +loadOrderings = [ + # Swift enum case, C order + ('relaxed', 'relaxed'), + ('acquiring', 'acquire'), + ('sequentiallyConsistent', 'seq_cst'), +] + +storeOrderings = [ + # Swift enum case, C order + ('relaxed', 'relaxed'), + ('releasing', 'release'), + ('sequentiallyConsistent', 'seq_cst'), +] + +updateOrderings = [ + # Swift enum case, C order fail order + ('relaxed', 'relaxed', 'relaxed'), + ('acquiring', 'acquire', 'acquire'), + ('releasing', 'release', 'relaxed'), + ('acquiringAndReleasing', 'acq_rel', 'acquire'), + ('sequentiallyConsistent', 'seq_cst', 'seq_cst'), +] + +# stdatomic.h (and LLVM underneath) doesn't support arbitrary ordering +# combinations yet, so for the two-ordering cmpxchg variants we need +# to upgrade the success ordering when necessary so that it is at +# least as "strong" as the failure case. This function implements that +# mapping. +# +# See llvm/Support/AtomicOrdering.h +def shimOrders(success, failure): + def max(success, failure): + if failure == "acquire": + if success == "relaxed": + return "acquire" + if success == "release": + return "acq_rel" + if failure == "seq_cst": + return "seq_cst" + return success + return max(success, failure) + "_" + failure + +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") +] + +boolOperations = [ + # Swift name, C name, operator, label, doc + ('LogicalAnd', 'and', '&&', "with", "logical AND"), + ('LogicalOr', 'or', '||', "with", "logical OR"), + ('LogicalXor', 'xor', '!=', "with", "logical XOR") +] + +def lowerFirst(str): + return str[:1].lower() + str[1:] if str else "" + +def argLabel(label): + return label + ": " if label <> "_" else "" + diff --git a/generate-sources b/generate-sources new file mode 100755 index 0000000..5d9004f --- /dev/null +++ b/generate-sources @@ -0,0 +1,72 @@ +#!/bin/sh +#===----------------------------------------------------------------------===// +# +# 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 +# +#===----------------------------------------------------------------------===// + +set -eu + +srcroot="$(dirname "$0")" +cd "$srcroot" + +gyb="./Utilities/gyb" + +# Disable line directives in gyb output. We commit generated sources +# into the package repository, so we do not want absolute file names +# in them. +lineDirective='' + +# Uncomment the following line to enable #sourceLocation directives. +# This is useful for local development. +#lineDirective='#sourceLocation(file: "%(file)s", line: %(line)d)' + + +echo "Running gyb..." + +# Create a temporary directory; remove it on exit. +tmpdir="$(mktemp -d -t "$(basename "$0")")" +trap "rm -rf \"$tmpdir\"" EXIT + +# Run gyb on each gyb file in the source tree and put results in +# subdirectories named 'autogenerated'. +for input in ./Sources/*/*.gyb ./Tests/*/*.gyb; do + basename="$(basename "$input")" + targetdir="$(dirname "$input")/autogenerated" + output="$targetdir/"${basename%.gyb} + tmpfile="$tmpdir/${basename%.gyb}" + + # Make sure the output directory exists. + mkdir -p "$targetdir" + + # Run gyb, making sure to only update files when they change. + "$gyb" --line-directive "$lineDirective" -o "$tmpfile" "$input" + if [ -e "$output" ] && cmp -s "$tmpfile" "$output"; then + : Ignore unchanged file + else + echo "Updated $output" + cp "$tmpfile" "$output" + fi + echo "$output" >> "$tmpdir/generated-files.txt" +done + +# Warn user if there are any autogenerated files without a corresponding gyb. +find . -path '*/autogenerated/*.swift' >> "$tmpdir/generated-files.txt" +sort "$tmpdir/generated-files.txt" | uniq -u | while read obsolete; do + echo "Removing $obsolete" + rm "$obsolete" +done + +# Generate XCTest test registry for platforms without the Objective-C runtime. +if [ "$(uname)" = Darwin ]; then + echo "Registering tests..." + swift test --generate-linuxmain +fi + +echo "All done!"