[atomics] - C++20 → C++23

Files changed (1) hide show

tmp/tmpmevuj5r9/{from.md → to.md} +592 -452

tmp/tmpmevuj5r9/{from.md → to.md} RENAMED Viewed

@@ -1,291 +1,301 @@
-# Atomic operations library <a id="atomics">[[atomics]]</a>
-## General <a id="atomics.general">[[atomics.general]]</a>
-This Clause describes components for fine-grained atomic access. This
-access is provided via operations on atomic objects.
-The following subclauses describe atomics requirements and components
-for types and operations, as summarized in [[atomics.summary]].
-**Table: Atomics library summary** <a id="atomics.summary">[atomics.summary]</a>
-| Subclause                 |                             | Header     |
-| ------------------------- | --------------------------- | ---------- |
-| [[atomics.alias]]         | Type aliases                | `<atomic>` |
-| [[atomics.order]]         | Order and consistency       |            |
-| [[atomics.lockfree]]      | Lock-free property          |            |
-| [[atomics.wait]]          | Waiting and notifying       |            |
-| [[atomics.ref.generic]]   | Class template `atomic_ref` |            |
-| [[atomics.types.generic]] | Class template `atomic`     |            |
-| [[atomics.nonmembers]]    | Non-member functions        |            |
-| [[atomics.flag]]          | Flag type and operations    |            |
-| [[atomics.fences]]        | Fences                      |            |
-## Header `<atomic>` synopsis <a id="atomics.syn">[[atomics.syn]]</a>
 ``` cpp
 namespace std {
   // [atomics.order], order and consistency
-  enum class memory_order : unspecified;
   template<class T>
-    T kill_dependency(T y) noexcept;
 // [atomics.lockfree], lock-free property
- #define ATOMIC_BOOL_LOCK_FREE unspecified
- #define ATOMIC_CHAR_LOCK_FREE unspecified
- #define ATOMIC_CHAR8_T_LOCK_FREE unspecified
- #define ATOMIC_CHAR16_T_LOCK_FREE unspecified
- #define ATOMIC_CHAR32_T_LOCK_FREE unspecified
- #define ATOMIC_WCHAR_T_LOCK_FREE unspecified
- #define ATOMIC_SHORT_LOCK_FREE unspecified
- #define ATOMIC_INT_LOCK_FREE unspecified
- #define ATOMIC_LONG_LOCK_FREE unspecified
- #define ATOMIC_LLONG_LOCK_FREE unspecified
- #define ATOMIC_POINTER_LOCK_FREE unspecified
   // [atomics.ref.generic], class template atomic_ref
-  template<class T> struct atomic_ref;
   // [atomics.ref.pointer], partial specialization for pointers
-  template<class T> struct atomic_ref<T*>;
   // [atomics.types.generic], class template atomic
-  template<class T> struct atomic;
   // [atomics.types.pointer], partial specialization for pointers
-  template<class T> struct atomic<T*>;
   // [atomics.nonmembers], non-member functions
   template<class T>
-    bool atomic_is_lock_free(const volatile atomic<T>*) noexcept;
   template<class T>
-    bool atomic_is_lock_free(const atomic<T>*) noexcept;
   template<class T>
-    void atomic_store(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
   template<class T>
-    void atomic_store(atomic<T>*, typename atomic<T>::value_type) noexcept;
   template<class T>
-    void atomic_store_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
                                memory_order) noexcept;
   template<class T>
-    void atomic_store_explicit(atomic<T>*, typename atomic<T>::value_type,
                                memory_order) noexcept;
   template<class T>
-    T atomic_load(const volatile atomic<T>*) noexcept;
   template<class T>
-    T atomic_load(const atomic<T>*) noexcept;
   template<class T>
-    T atomic_load_explicit(const volatile atomic<T>*, memory_order) noexcept;
   template<class T>
-    T atomic_load_explicit(const atomic<T>*, memory_order) noexcept;
   template<class T>
-    T atomic_exchange(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
   template<class T>
-    T atomic_exchange(atomic<T>*, typename atomic<T>::value_type) noexcept;
   template<class T>
-    T atomic_exchange_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
                                memory_order) noexcept;
   template<class T>
-    T atomic_exchange_explicit(atomic<T>*, typename atomic<T>::value_type,
                                memory_order) noexcept;
   template<class T>
-    bool atomic_compare_exchange_weak(volatile atomic<T>*,
                                       typename atomic<T>::value_type*,
                                       typename atomic<T>::value_type) noexcept;
   template<class T>
-    bool atomic_compare_exchange_weak(atomic<T>*,
                                       typename atomic<T>::value_type*,
                                       typename atomic<T>::value_type) noexcept;
   template<class T>
-    bool atomic_compare_exchange_strong(volatile atomic<T>*,
                                         typename atomic<T>::value_type*,
                                         typename atomic<T>::value_type) noexcept;
   template<class T>
-    bool atomic_compare_exchange_strong(atomic<T>*,
                                         typename atomic<T>::value_type*,
                                         typename atomic<T>::value_type) noexcept;
   template<class T>
-    bool atomic_compare_exchange_weak_explicit(volatile atomic<T>*,
                                                typename atomic<T>::value_type*,
                                                typename atomic<T>::value_type,
                                                memory_order, memory_order) noexcept;
   template<class T>
-    bool atomic_compare_exchange_weak_explicit(atomic<T>*,
                                                typename atomic<T>::value_type*,
                                                typename atomic<T>::value_type,
                                                memory_order, memory_order) noexcept;
   template<class T>
-    bool atomic_compare_exchange_strong_explicit(volatile atomic<T>*,
                                                  typename atomic<T>::value_type*,
                                                  typename atomic<T>::value_type,
                                                  memory_order, memory_order) noexcept;
   template<class T>
-    bool atomic_compare_exchange_strong_explicit(atomic<T>*,
                                                  typename atomic<T>::value_type*,
                                                  typename atomic<T>::value_type,
                                                  memory_order, memory_order) noexcept;
   template<class T>
-    T atomic_fetch_add(volatile atomic<T>*, typename atomic<T>::difference_type) noexcept;
   template<class T>
-    T atomic_fetch_add(atomic<T>*, typename atomic<T>::difference_type) noexcept;
   template<class T>
-    T atomic_fetch_add_explicit(volatile atomic<T>*, typename atomic<T>::difference_type,
                                 memory_order) noexcept;
   template<class T>
-    T atomic_fetch_add_explicit(atomic<T>*, typename atomic<T>::difference_type,
                                 memory_order) noexcept;
   template<class T>
-    T atomic_fetch_sub(volatile atomic<T>*, typename atomic<T>::difference_type) noexcept;
   template<class T>
-    T atomic_fetch_sub(atomic<T>*, typename atomic<T>::difference_type) noexcept;
   template<class T>
-    T atomic_fetch_sub_explicit(volatile atomic<T>*, typename atomic<T>::difference_type,
                                 memory_order) noexcept;
   template<class T>
-    T atomic_fetch_sub_explicit(atomic<T>*, typename atomic<T>::difference_type,
                                 memory_order) noexcept;
   template<class T>
-    T atomic_fetch_and(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
   template<class T>
-    T atomic_fetch_and(atomic<T>*, typename atomic<T>::value_type) noexcept;
   template<class T>
-    T atomic_fetch_and_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
                                 memory_order) noexcept;
   template<class T>
-    T atomic_fetch_and_explicit(atomic<T>*, typename atomic<T>::value_type,
                                 memory_order) noexcept;
   template<class T>
-    T atomic_fetch_or(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
   template<class T>
-    T atomic_fetch_or(atomic<T>*, typename atomic<T>::value_type) noexcept;
   template<class T>
-    T atomic_fetch_or_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
                                memory_order) noexcept;
   template<class T>
-    T atomic_fetch_or_explicit(atomic<T>*, typename atomic<T>::value_type,
                                memory_order) noexcept;
   template<class T>
-    T atomic_fetch_xor(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
   template<class T>
-    T atomic_fetch_xor(atomic<T>*, typename atomic<T>::value_type) noexcept;
   template<class T>
-    T atomic_fetch_xor_explicit(volatile atomic<T>*, typename atomic<T>::value_type,
                                 memory_order) noexcept;
   template<class T>
-    T atomic_fetch_xor_explicit(atomic<T>*, typename atomic<T>::value_type,
                                 memory_order) noexcept;
   template<class T>
-    void atomic_wait(const volatile atomic<T>*, typename atomic<T>::value_type);
   template<class T>
-    void atomic_wait(const atomic<T>*, typename atomic<T>::value_type);
   template<class T>
-    void atomic_wait_explicit(const volatile atomic<T>*, typename atomic<T>::value_type,
- memory_order);
   template<class T>
-    void atomic_wait_explicit(const atomic<T>*, typename atomic<T>::value_type,
-                              memory_order);
   template<class T>
-    void atomic_notify_one(volatile atomic<T>*);
   template<class T>
-    void atomic_notify_one(atomic<T>*);
   template<class T>
-    void atomic_notify_all(volatile atomic<T>*);
   template<class T>
-    void atomic_notify_all(atomic<T>*);
   // [atomics.alias], type aliases
-  using atomic_bool           = atomic<bool>;
-  using atomic_char           = atomic<char>;
-  using atomic_schar          = atomic<signed char>;
-  using atomic_uchar          = atomic<unsigned char>;
-  using atomic_short          = atomic<short>;
-  using atomic_ushort         = atomic<unsigned short>;
-  using atomic_int            = atomic<int>;
-  using atomic_uint           = atomic<unsigned int>;
-  using atomic_long           = atomic<long>;
-  using atomic_ulong          = atomic<unsigned long>;
-  using atomic_llong          = atomic<long long>;
-  using atomic_ullong         = atomic<unsigned long long>;
-  using atomic_char8_t        = atomic<char8_t>;
-  using atomic_char16_t       = atomic<char16_t>;
-  using atomic_char32_t       = atomic<char32_t>;
-  using atomic_wchar_t        = atomic<wchar_t>;
-  using atomic_int8_t         = atomic<int8_t>;
-  using atomic_uint8_t        = atomic<uint8_t>;
-  using atomic_int16_t        = atomic<int16_t>;
-  using atomic_uint16_t       = atomic<uint16_t>;
-  using atomic_int32_t        = atomic<int32_t>;
-  using atomic_uint32_t       = atomic<uint32_t>;
-  using atomic_int64_t        = atomic<int64_t>;
-  using atomic_uint64_t       = atomic<uint64_t>;
-  using atomic_int_least8_t   = atomic<int_least8_t>;
-  using atomic_uint_least8_t  = atomic<uint_least8_t>;
-  using atomic_int_least16_t  = atomic<int_least16_t>;
-  using atomic_uint_least16_t = atomic<uint_least16_t>;
-  using atomic_int_least32_t  = atomic<int_least32_t>;
-  using atomic_uint_least32_t = atomic<uint_least32_t>;
-  using atomic_int_least64_t  = atomic<int_least64_t>;
-  using atomic_uint_least64_t = atomic<uint_least64_t>;
-  using atomic_int_fast8_t    = atomic<int_fast8_t>;
-  using atomic_uint_fast8_t   = atomic<uint_fast8_t>;
-  using atomic_int_fast16_t   = atomic<int_fast16_t>;
-  using atomic_uint_fast16_t  = atomic<uint_fast16_t>;
-  using atomic_int_fast32_t   = atomic<int_fast32_t>;
-  using atomic_uint_fast32_t  = atomic<uint_fast32_t>;
-  using atomic_int_fast64_t   = atomic<int_fast64_t>;
-  using atomic_uint_fast64_t  = atomic<uint_fast64_t>;
-  using atomic_intptr_t       = atomic<intptr_t>;
-  using atomic_uintptr_t      = atomic<uintptr_t>;
-  using atomic_size_t         = atomic<size_t>;
-  using atomic_ptrdiff_t      = atomic<ptrdiff_t>;
-  using atomic_intmax_t       = atomic<intmax_t>;
-  using atomic_uintmax_t      = atomic<uintmax_t>;
   using atomic_signed_lock_free   = see below;
   using atomic_unsigned_lock_free = see below;
   // [atomics.flag], flag type and operations
-  struct atomic_flag;
-  bool atomic_flag_test(const volatile atomic_flag*) noexcept;
-  bool atomic_flag_test(const atomic_flag*) noexcept;
-  bool atomic_flag_test_explicit(const volatile atomic_flag*, memory_order) noexcept;
-  bool atomic_flag_test_explicit(const atomic_flag*, memory_order) noexcept;
-  bool atomic_flag_test_and_set(volatile atomic_flag*) noexcept;
-  bool atomic_flag_test_and_set(atomic_flag*) noexcept;
-  bool atomic_flag_test_and_set_explicit(volatile atomic_flag*, memory_order) noexcept;
-  bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order) noexcept;
-  void atomic_flag_clear(volatile atomic_flag*) noexcept;
- void atomic_flag_clear(atomic_flag*) noexcept;
-  void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order) noexcept;
-  void atomic_flag_clear_explicit(atomic_flag*, memory_order) noexcept;
-  void atomic_flag_wait(const volatile atomic_flag*, bool) noexcept;
-  void atomic_flag_wait(const atomic_flag*, bool) noexcept;
-  void atomic_flag_wait_explicit(const volatile atomic_flag*,
                                  bool, memory_order) noexcept;
-  void atomic_flag_wait_explicit(const atomic_flag*,
                                  bool, memory_order) noexcept;
-  void atomic_flag_notify_one(volatile atomic_flag*) noexcept;
-  void atomic_flag_notify_one(atomic_flag*) noexcept;
-  void atomic_flag_notify_all(volatile atomic_flag*) noexcept;
-  void atomic_flag_notify_all(atomic_flag*) noexcept;
   // [atomics.fences], fences
-  extern "C" void atomic_thread_fence(memory_order) noexcept;
-  extern "C" void atomic_signal_fence(memory_order) noexcept;
 }
 ```
-## Type aliases <a id="atomics.alias">[[atomics.alias]]</a>
 The type aliases `atomic_intN_t`, `atomic_uintN_t`, `atomic_intptr_t`,
 and `atomic_uintptr_t` are defined if and only if `intN_t`, `uintN_t`,
 `intptr_t`, and `uintptr_t` are defined, respectively.
@@ -299,23 +309,17 @@ and whose `is_always_lock_free` property is `true`.
 Implementations should choose for these aliases the integral
 specializations of `atomic` for which the atomic waiting and notifying
 operations [[atomics.wait]] are most efficient.
-## Order and consistency <a id="atomics.order">[[atomics.order]]</a>
 ``` cpp
 namespace std {
   enum class memory_order : unspecified {
     relaxed, consume, acquire, release, acq_rel, seq_cst
   };
-  inline constexpr memory_order memory_order_relaxed = memory_order::relaxed;
-  inline constexpr memory_order memory_order_consume = memory_order::consume;
-  inline constexpr memory_order memory_order_acquire = memory_order::acquire;
-  inline constexpr memory_order memory_order_release = memory_order::release;
-  inline constexpr memory_order memory_order_acq_rel = memory_order::acq_rel;
-  inline constexpr memory_order memory_order_seq_cst = memory_order::seq_cst;
 }
 ```
 The enumeration `memory_order` specifies the detailed regular
 (non-atomic) memory synchronization order as defined in
@@ -413,14 +417,14 @@ x.store(r1, memory_order::relaxed);
 // Thread 2:
 r2 = x.load(memory_order::relaxed);
 y.store(r2, memory_order::relaxed);
 ```
-should not produce `r1 == r2 == 42`, since the store of 42 to `y` is
-only possible if the store to `x` stores `42`, which circularly depends
-on the store to `y` storing `42`. Note that without this restriction,
-such an execution is possible.
 — *end note*]
 [*Note 7*:
@@ -456,11 +460,11 @@ template<class T>
 *Effects:* The argument does not carry a dependency to the return
 value [[intro.multithread]].
 *Returns:* `y`.
-## Lock-free property <a id="atomics.lockfree">[[atomics.lockfree]]</a>
 ``` cpp
 #define ATOMIC_BOOL_LOCK_FREE unspecified
 #define ATOMIC_CHAR_LOCK_FREE unspecified
 #define ATOMIC_CHAR8_T_LOCK_FREE unspecified
@@ -480,33 +484,34 @@ grouped together. The properties also apply to the corresponding
 (partial) specializations of the `atomic` template. A value of 0
 indicates that the types are never lock-free. A value of 1 indicates
 that the types are sometimes lock-free. A value of 2 indicates that the
 types are always lock-free.
-At least one signed integral specialization of the `atomic` template,
-along with the specialization for the corresponding unsigned type
-[[basic.fundamental]], is always lock-free.
-[*Note 1*: This requirement is optional in freestanding implementations
-[[compliance]]. — *end note*]
-The function `atomic_is_lock_free` [[atomics.types.operations]]
-indicates whether the object is lock-free. In any given program
-execution, the result of the lock-free query shall be consistent for all
-pointers of the same type.
 Atomic operations that are not lock-free are considered to potentially
 block [[intro.progress]].
-[*Note 2*: Operations that are lock-free should also be address-free.
-That is, atomic operations on the same memory location via two different
-addresses will communicate atomically. The implementation should not
-depend on any per-process state. This restriction enables communication
-by memory that is mapped into a process more than once and by memory
-that is shared between two processes. — *end note*]
-## Waiting and notifying <a id="atomics.wait">[[atomics.wait]]</a>
 *Atomic waiting operations* and *atomic notifying operations* provide a
 mechanism to wait for the value of an atomic object to change more
 efficiently than can be achieved with polling. An atomic waiting
 operation may block until it is unblocked by an atomic notifying
@@ -547,17 +552,20 @@ A call to an atomic waiting operation on an atomic object `M` is
 - the atomic waiting operation has blocked after observing the result of
   `X`,
 - `X` precedes `Y` in the modification order of `M`, and
 - `Y` happens before the call to the atomic notifying operation.
-## Class template `atomic_ref` <a id="atomics.ref.generic">[[atomics.ref.generic]]</a>
 ``` cpp
 namespace std {
   template<class T> struct atomic_ref {
   private:
     T* ptr;             // exposition only
   public:
     using value_type = T;
     static constexpr size_t required_alignment = implementation-defined  // required alignment for atomic_ref type's operations;
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic_ref type's operations are always lock free;
@@ -606,16 +614,16 @@ object.
 Atomic operations applied to an object through a referencing
 `atomic_ref` are atomic with respect to atomic operations applied
 through any other `atomic_ref` referencing the same object.
-[*Note 1*: Atomic operations or the `atomic_ref` constructor could
 acquire a shared resource, such as a lock associated with the referenced
 object, to enable atomic operations to be applied to the referenced
 object. — *end note*]
-### Operations <a id="atomics.ref.ops">[[atomics.ref.ops]]</a>
 ``` cpp
 static constexpr size_t required_alignment;
 ```
@@ -802,94 +810,96 @@ void notify_all() const noexcept;
 `*ptr` that are eligible to be unblocked [[atomics.wait]] by this call.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]] on atomic object `*ptr`.
-### Specializations for integral types <a id="atomics.ref.int">[[atomics.ref.int]]</a>
 There are specializations of the `atomic_ref` class template for the
 integral types `char`, `signed char`, `unsigned char`, `short`,
 `unsigned short`, `int`, `unsigned int`, `long`, `unsigned long`,
 `long long`, `unsigned long long`, `char8_t`, `char16_t`, `char32_t`,
 `wchar_t`, and any other types needed by the typedefs in the header
-`<cstdint>`. For each such type `integral`, the specialization
-`atomic_ref<integral>` provides additional atomic operations appropriate
-to integral types.
 [*Note 1*: The specialization `atomic_ref<bool>` uses the primary
 template [[atomics.ref.generic]]. — *end note*]
 ``` cpp
 namespace std {
-  template<> struct atomic_ref<integral> {
   private:
-    integral* ptr; // exposition only
   public:
-    using value_type = integral;
     using difference_type = value_type;
     static constexpr size_t required_alignment = implementation-defined  // required alignment for atomic_ref type's operations;
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic_ref type's operations are always lock free;
     bool is_lock_free() const noexcept;
-    explicit atomic_ref(integral&);
     atomic_ref(const atomic_ref&) noexcept;
     atomic_ref& operator=(const atomic_ref&) = delete;
-    void store(integral, memory_order = memory_order::seq_cst) const noexcept;
-    integral operator=(integral) const noexcept;
-    integral load(memory_order = memory_order::seq_cst) const noexcept;
-    operator integral() const noexcept;
-    integral exchange(integral,
                            memory_order = memory_order::seq_cst) const noexcept;
-    bool compare_exchange_weak(integral&, integral,
                                memory_order, memory_order) const noexcept;
-    bool compare_exchange_strong(integral&, integral,
                                  memory_order, memory_order) const noexcept;
-    bool compare_exchange_weak(integral&, integral,
                                memory_order = memory_order::seq_cst) const noexcept;
-    bool compare_exchange_strong(integral&, integral,
                                  memory_order = memory_order::seq_cst) const noexcept;
-    integral fetch_add(integral,
                             memory_order = memory_order::seq_cst) const noexcept;
-    integral fetch_sub(integral,
                             memory_order = memory_order::seq_cst) const noexcept;
-    integral fetch_and(integral,
                             memory_order = memory_order::seq_cst) const noexcept;
-    integral fetch_or(integral,
                             memory_order = memory_order::seq_cst) const noexcept;
-    integral fetch_xor(integral,
                             memory_order = memory_order::seq_cst) const noexcept;
-    integral operator++(int) const noexcept;
-    integral operator--(int) const noexcept;
-    integral operator++() const noexcept;
-    integral operator--() const noexcept;
-    integral operator+=(integral) const noexcept;
-    integral operator-=(integral) const noexcept;
-    integral operator&=(integral) const noexcept;
-    integral operator|=(integral) const noexcept;
-    integral operator^=(integral) const noexcept;
-    void wait(integral, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() const noexcept;
     void notify_all() const noexcept;
   };
 }
 ```
 Descriptions are provided below only for members that differ from the
 primary template.
-The following operations perform arithmetic computations. The key,
-operator, and computation correspondence is identified in
 [[atomic.types.int.comp]].
 ``` cpp
-integral fetch_key(integral operand, memory_order order = memory_order::seq_cst) const noexcept;
 ```
 *Effects:* Atomically replaces the value referenced by `*ptr` with the
 result of the computation applied to the value referenced by `*ptr` and
 the given operand. Memory is affected according to the value of `order`.
@@ -906,81 +916,82 @@ converted back to the signed type.
 [*Note 1*: There are no undefined results arising from the
 computation. — *end note*]
 ``` cpp
-integral operator op=(integral operand) const noexcept;
 ```
 *Effects:* Equivalent to:
 `return fetch_`*`key`*`(operand) `*`op`*` operand;`
-### Specializations for floating-point types <a id="atomics.ref.float">[[atomics.ref.float]]</a>
-There are specializations of the `atomic_ref` class template for the
-floating-point types `float`, `double`, and `long double`. For each such
-type `floating-point`, the specialization `atomic_ref<floating-point>`
 provides additional atomic operations appropriate to floating-point
 types.
 ``` cpp
 namespace std {
-  template<> struct atomic_ref<floating-point> {
   private:
-    floating-point* ptr; // exposition only
   public:
-    using value_type = floating-point;
     using difference_type = value_type;
     static constexpr size_t required_alignment = implementation-defined  // required alignment for atomic_ref type's operations;
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic_ref type's operations are always lock free;
     bool is_lock_free() const noexcept;
-    explicit atomic_ref(floating-point&);
     atomic_ref(const atomic_ref&) noexcept;
     atomic_ref& operator=(const atomic_ref&) = delete;
-    void store(floating-point, memory_order = memory_order::seq_cst) const noexcept;
-    floating-point operator=(floating-point) const noexcept;
-    floating-point load(memory_order = memory_order::seq_cst) const noexcept;
-    operator floating-point() const noexcept;
-    floating-point exchange(floating-point,
                                  memory_order = memory_order::seq_cst) const noexcept;
-    bool compare_exchange_weak(floating-point&, floating-point,
                                memory_order, memory_order) const noexcept;
-    bool compare_exchange_strong(floating-point&, floating-point,
                                  memory_order, memory_order) const noexcept;
-    bool compare_exchange_weak(floating-point&, floating-point,
                                memory_order = memory_order::seq_cst) const noexcept;
-    bool compare_exchange_strong(floating-point&, floating-point,
                                  memory_order = memory_order::seq_cst) const noexcept;
-    floating-point fetch_add(floating-point,
                                   memory_order = memory_order::seq_cst) const noexcept;
-    floating-point fetch_sub(floating-point,
                                   memory_order = memory_order::seq_cst) const noexcept;
-    floating-point operator+=(floating-point) const noexcept;
-    floating-point operator-=(floating-point) const noexcept;
-    void wait(floating-point, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() const noexcept;
     void notify_all() const noexcept;
   };
 }
 ```
 Descriptions are provided below only for members that differ from the
 primary template.
-The following operations perform arithmetic computations. The key,
-operator, and computation correspondence are identified in
 [[atomic.types.int.comp]].
 ``` cpp
-floating-point fetch_key(floating-point operand,
                           memory_order order = memory_order::seq_cst) const noexcept;
 ```
 *Effects:* Atomically replaces the value referenced by `*ptr` with the
 result of the computation applied to the value referenced by `*ptr` and
@@ -992,31 +1003,32 @@ operations [[intro.races]].
 the effects.
 *Remarks:* If the result is not a representable value for its
 type [[expr.pre]], the result is unspecified, but the operations
 otherwise have no undefined behavior. Atomic arithmetic operations on
-*`floating-point`* should conform to the
-`std::numeric_limits<`*`floating-point`*`>` traits associated with the
-floating-point type [[limits.syn]]. The floating-point
 environment [[cfenv]] for atomic arithmetic operations on
-*`floating-point`* may be different than the calling thread’s
 floating-point environment.
 ``` cpp
-floating-point operator op=(floating-point operand) const noexcept;
 ```
 *Effects:* Equivalent to:
 `return fetch_`*`key`*`(operand) `*`op`*` operand;`
-### Partial specialization for pointers <a id="atomics.ref.pointer">[[atomics.ref.pointer]]</a>
 ``` cpp
 namespace std {
   template<class T> struct atomic_ref<T*> {
   private:
     T** ptr;        // exposition only
   public:
     using value_type = T*;
     using difference_type = ptrdiff_t;
     static constexpr size_t required_alignment = implementation-defined  // required alignment for atomic_ref type's operations;
@@ -1060,12 +1072,12 @@ namespace std {
 ```
 Descriptions are provided below only for members that differ from the
 primary template.
-The following operations perform arithmetic computations. The key,
-operator, and computation correspondence is identified in
 [[atomic.types.pointer.comp]].
 ``` cpp
 T* fetch_key(difference_type operand, memory_order order = memory_order::seq_cst) const noexcept;
 ```
@@ -1089,11 +1101,11 @@ T* operator op=(difference_type operand) const noexcept;
 ```
 *Effects:* Equivalent to:
 `return fetch_`*`key`*`(operand) `*`op`*` operand;`
-### Member operators common to integers and pointers to objects <a id="atomics.ref.memop">[[atomics.ref.memop]]</a>
 ``` cpp
 value_type operator++(int) const noexcept;
 ```
@@ -1115,11 +1127,13 @@ value_type operator++() const noexcept;
 value_type operator--() const noexcept;
 ```
 *Effects:* Equivalent to: `return fetch_sub(1) - 1;`
-## Class template `atomic` <a id="atomics.types.generic">[[atomics.types.generic]]</a>
 ``` cpp
 namespace std {
   template<class T> struct atomic {
     using value_type = T;
@@ -1176,19 +1190,19 @@ of
 - `is_move_assignable_v<T>`
 is `false`.
 [*Note 1*: Type arguments that are not also statically initializable
-may be difficult to use. — *end note*]
 The specialization `atomic<bool>` is a standard-layout struct.
 [*Note 2*: The representation of an atomic specialization need not have
 the same size and alignment requirement as its corresponding argument
 type. — *end note*]
-### Operations on atomic types <a id="atomics.types.operations">[[atomics.types.operations]]</a>
 ``` cpp
 constexpr atomic() noexcept(is_nothrow_default_constructible_v<T>);
 ```
@@ -1237,17 +1251,17 @@ type. — *end note*]
 ``` cpp
 void store(T desired, memory_order order = memory_order::seq_cst) volatile noexcept;
 void store(T desired, memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Preconditions:* The `order` argument is neither
 `memory_order::consume`, `memory_order::acquire`, nor
 `memory_order::acq_rel`.
-*Constraints:* For the `volatile` overload of this function,
-`is_always_lock_free` is `true`.
 *Effects:* Atomically replaces the value pointed to by `this` with the
 value of `desired`. Memory is affected according to the value of
 `order`.
 ``` cpp
@@ -1265,16 +1279,16 @@ T operator=(T desired) noexcept;
 ``` cpp
 T load(memory_order order = memory_order::seq_cst) const volatile noexcept;
 T load(memory_order order = memory_order::seq_cst) const noexcept;
 ```
-*Preconditions:* The `order` argument is neither `memory_order::release`
-nor `memory_order::acq_rel`.
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 *Effects:* Memory is affected according to the value of `order`.
 *Returns:* Atomically returns the value pointed to by `this`.
 ``` cpp
@@ -1320,16 +1334,16 @@ bool compare_exchange_strong(T& expected, T desired,
                              memory_order order = memory_order::seq_cst) volatile noexcept;
 bool compare_exchange_strong(T& expected, T desired,
                              memory_order order = memory_order::seq_cst) noexcept;
 ```
-*Preconditions:* The `failure` argument is neither
-`memory_order::release` nor `memory_order::acq_rel`.
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 *Effects:* Retrieves the value in `expected`. It then atomically
 compares the value representation of the value pointed to by `this` for
 equality with that previously retrieved from `expected`, and if true,
 replaces the value pointed to by `this` with that in `desired`. If and
 only if the comparison is `true`, memory is affected according to the
@@ -1349,17 +1363,17 @@ Otherwise, these operations are atomic load operations on that memory.
 *Returns:* The result of the comparison.
 [*Note 4*:
 For example, the effect of `compare_exchange_strong` on objects without
-padding bits [[basic.types]] is
 ``` cpp
 if (memcmp(this, &expected, sizeof(*this)) == 0)
   memcpy(this, &desired, sizeof(*this));
 else
-  memcpy(expected, this, sizeof(*this));
 ```
 — *end note*]
 [*Example 1*:
@@ -1410,17 +1424,17 @@ compare-and-exchange is in a loop, the weak version will yield better
 performance on some platforms. When a weak compare-and-exchange would
 require a loop and a strong one would not, the strong one is
 preferable. — *end note*]
 [*Note 6*: Under cases where the `memcpy` and `memcmp` semantics of the
-compare-and-exchange operations apply, the outcome might be failed
-comparisons for values that compare equal with `operator==` if the value
-representation has trap bits or alternate representations of the same
-value. Notably, on implementations conforming to ISO/IEC/IEEE 60559,
-floating-point `-0.0` and `+0.0` will not compare equal with `memcmp`
-but will compare equal with `operator==`, and NaNs with the same payload
-will compare equal with `memcmp` but will not compare equal with
 `operator==`. — *end note*]
 [*Note 7*:
 Because compare-and-exchange acts on an object’s value representation,
@@ -1507,100 +1521,112 @@ void notify_all() noexcept;
 are eligible to be unblocked [[atomics.wait]] by this call.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]].
-### Specializations for integers <a id="atomics.types.int">[[atomics.types.int]]</a>
 There are specializations of the `atomic` class template for the
 integral types `char`, `signed char`, `unsigned char`, `short`,
 `unsigned short`, `int`, `unsigned int`, `long`, `unsigned long`,
 `long long`, `unsigned long long`, `char8_t`, `char16_t`, `char32_t`,
 `wchar_t`, and any other types needed by the typedefs in the header
-`<cstdint>`. For each such type `integral`, the specialization
-`atomic<integral>` provides additional atomic operations appropriate to
-integral types.
 [*Note 1*: The specialization `atomic<bool>` uses the primary template
 [[atomics.types.generic]]. — *end note*]
 ``` cpp
 namespace std {
-  template<> struct atomic<integral> {
-    using value_type = integral;
     using difference_type = value_type;
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic type's operations are always lock free;
     bool is_lock_free() const volatile noexcept;
     bool is_lock_free() const noexcept;
     constexpr atomic() noexcept;
-    constexpr atomic(integral) noexcept;
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
-    void store(integral, memory_order = memory_order::seq_cst) volatile noexcept;
-    void store(integral, memory_order = memory_order::seq_cst) noexcept;
-    integral operator=(integral) volatile noexcept;
-    integral operator=(integral) noexcept;
-    integral load(memory_order = memory_order::seq_cst) const volatile noexcept;
-    integral load(memory_order = memory_order::seq_cst) const noexcept;
-    operator integral() const volatile noexcept;
-    operator integral() const noexcept;
-    integral exchange(integral, memory_order = memory_order::seq_cst) volatile noexcept;
-    integral exchange(integral, memory_order = memory_order::seq_cst) noexcept;
- bool compare_exchange_weak(integral&, integral,
                                memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_weak(integral&, integral,
                                memory_order, memory_order) noexcept;
-    bool compare_exchange_strong(integral&, integral,
                                  memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_strong(integral&, integral,
                                  memory_order, memory_order) noexcept;
-    bool compare_exchange_weak(integral&, integral,
                                memory_order = memory_order::seq_cst) volatile noexcept;
-    bool compare_exchange_weak(integral&, integral,
                                memory_order = memory_order::seq_cst) noexcept;
-    bool compare_exchange_strong(integral&, integral,
                                  memory_order = memory_order::seq_cst) volatile noexcept;
-    bool compare_exchange_strong(integral&, integral,
                                  memory_order = memory_order::seq_cst) noexcept;
-    integral fetch_add(integral, memory_order = memory_order::seq_cst) volatile noexcept;
-    integral fetch_add(integral, memory_order = memory_order::seq_cst) noexcept;
-    integral fetch_sub(integral, memory_order = memory_order::seq_cst) volatile noexcept;
-    integral fetch_sub(integral, memory_order = memory_order::seq_cst) noexcept;
-    integral fetch_and(integral, memory_order = memory_order::seq_cst) volatile noexcept;
-    integral fetch_and(integral, memory_order = memory_order::seq_cst) noexcept;
-    integral fetch_or(integral, memory_order = memory_order::seq_cst) volatile noexcept;
-    integral fetch_or(integral, memory_order = memory_order::seq_cst) noexcept;
-    integral fetch_xor(integral, memory_order = memory_order::seq_cst) volatile noexcept;
-    integral fetch_xor(integral, memory_order = memory_order::seq_cst) noexcept;
-    integral operator++(int) volatile noexcept;
-    integral operator++(int) noexcept;
-    integral operator--(int) volatile noexcept;
-    integral operator--(int) noexcept;
-    integral operator++() volatile noexcept;
-    integral operator++() noexcept;
-    integral operator--() volatile noexcept;
-    integral operator--() noexcept;
-    integral operator+=(integral) volatile noexcept;
-    integral operator+=(integral) noexcept;
-    integral operator-=(integral) volatile noexcept;
-    integral operator-=(integral) noexcept;
-    integral operator&=(integral) volatile noexcept;
-    integral operator&=(integral) noexcept;
-    integral operator|=(integral) volatile noexcept;
-    integral operator|=(integral) noexcept;
-    integral operator^=(integral) volatile noexcept;
-    integral operator^=(integral) noexcept;
-    void wait(integral, memory_order = memory_order::seq_cst) const volatile noexcept;
-    void wait(integral, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() volatile noexcept;
     void notify_one() noexcept;
     void notify_all() volatile noexcept;
     void notify_all() noexcept;
   };
@@ -1611,12 +1637,13 @@ The atomic integral specializations are standard-layout structs. They
 each have a trivial destructor.
 Descriptions are provided below only for members that differ from the
 primary template.
-The following operations perform arithmetic computations. The key,
-operator, and computation correspondence is:
 **Table: Atomic arithmetic computations** <a id="atomic.types.int.comp">[atomic.types.int.comp]</a>
 |       |     |                      |       |     |                      |
 | ----- | --- | -------------------- | ----- | --- | -------------------- |
@@ -1658,80 +1685,80 @@ T operator op=(T operand) noexcept;
 `is_always_lock_free` is `true`.
 *Effects:* Equivalent to:
 `return fetch_`*`key`*`(operand) `*`op`*` operand;`
-### Specializations for floating-point types <a id="atomics.types.float">[[atomics.types.float]]</a>
-There are specializations of the `atomic` class template for the
-floating-point types `float`, `double`, and `long double`. For each such
-type `floating-point`, the specialization `atomic<floating-point>`
 provides additional atomic operations appropriate to floating-point
 types.
 ``` cpp
 namespace std {
-  template<> struct atomic<floating-point> {
-    using value_type = floating-point;
     using difference_type = value_type;
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic type's operations are always lock free;
     bool is_lock_free() const volatile noexcept;
     bool is_lock_free() const noexcept;
     constexpr atomic() noexcept;
-    constexpr atomic(floating-point) noexcept;
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
-    void store(floating-point, memory_order = memory_order::seq_cst) volatile noexcept;
-    void store(floating-point, memory_order = memory_order::seq_cst) noexcept;
-    floating-point operator=(floating-point) volatile noexcept;
-    floating-point operator=(floating-point) noexcept;
-    floating-point load(memory_order = memory_order::seq_cst) volatile noexcept;
-    floating-point load(memory_order = memory_order::seq_cst) noexcept;
-    operator floating-point() volatile noexcept;
-    operator floating-point() noexcept;
-    floating-point exchange(floating-point,
                                  memory_order = memory_order::seq_cst) volatile noexcept;
-    floating-point exchange(floating-point,
                                  memory_order = memory_order::seq_cst) noexcept;
-    bool compare_exchange_weak(floating-point&, floating-point,
                                memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_weak(floating-point&, floating-point,
                                memory_order, memory_order) noexcept;
-    bool compare_exchange_strong(floating-point&, floating-point,
                                  memory_order, memory_order) volatile noexcept;
-    bool compare_exchange_strong(floating-point&, floating-point,
                                  memory_order, memory_order) noexcept;
-    bool compare_exchange_weak(floating-point&, floating-point,
                                memory_order = memory_order::seq_cst) volatile noexcept;
-    bool compare_exchange_weak(floating-point&, floating-point,
                                memory_order = memory_order::seq_cst) noexcept;
-    bool compare_exchange_strong(floating-point&, floating-point,
                                  memory_order = memory_order::seq_cst) volatile noexcept;
-    bool compare_exchange_strong(floating-point&, floating-point,
                                  memory_order = memory_order::seq_cst) noexcept;
-    floating-point fetch_add(floating-point,
                                   memory_order = memory_order::seq_cst) volatile noexcept;
-    floating-point fetch_add(floating-point,
                                   memory_order = memory_order::seq_cst) noexcept;
-    floating-point fetch_sub(floating-point,
                                   memory_order = memory_order::seq_cst) volatile noexcept;
-    floating-point fetch_sub(floating-point,
                                   memory_order = memory_order::seq_cst) noexcept;
-    floating-point operator+=(floating-point) volatile noexcept;
-    floating-point operator+=(floating-point) noexcept;
-    floating-point operator-=(floating-point) volatile noexcept;
-    floating-point operator-=(floating-point) noexcept;
-    void wait(floating-point, memory_order = memory_order::seq_cst) const volatile noexcept;
-    void wait(floating-point, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() volatile noexcept;
     void notify_one() noexcept;
     void notify_all() volatile noexcept;
     void notify_all() noexcept;
   };
@@ -1743,12 +1770,12 @@ They each have a trivial destructor.
 Descriptions are provided below only for members that differ from the
 primary template.
 The following operations perform arithmetic addition and subtraction
-computations. The key, operator, and computation correspondence are
-identified in [[atomic.types.int.comp]].
 ``` cpp
 T fetch_key(T operand, memory_order order = memory_order::seq_cst) volatile noexcept;
 T fetch_key(T operand, memory_order order = memory_order::seq_cst) noexcept;
 ```
@@ -1766,15 +1793,15 @@ operations [[intro.multithread]].
 the effects.
 *Remarks:* If the result is not a representable value for its
 type [[expr.pre]] the result is unspecified, but the operations
 otherwise have no undefined behavior. Atomic arithmetic operations on
-*`floating-point`* should conform to the
-`std::numeric_limits<`*`floating-point`*`>` traits associated with the
-floating-point type [[limits.syn]]. The floating-point
 environment [[cfenv]] for atomic arithmetic operations on
-*`floating-point`* may be different than the calling thread’s
 floating-point environment.
 ``` cpp
 T operator op=(T operand) volatile noexcept;
 T operator op=(T operand) noexcept;
@@ -1787,18 +1814,18 @@ T operator op=(T operand) noexcept;
 `return fetch_`*`key`*`(operand) `*`op`*` operand;`
 *Remarks:* If the result is not a representable value for its
 type [[expr.pre]] the result is unspecified, but the operations
 otherwise have no undefined behavior. Atomic arithmetic operations on
-*`floating-point`* should conform to the
-`std::numeric_limits<`*`floating-point`*`>` traits associated with the
-floating-point type [[limits.syn]]. The floating-point
 environment [[cfenv]] for atomic arithmetic operations on
-*`floating-point`* may be different than the calling thread’s
 floating-point environment.
-### Partial specialization for pointers <a id="atomics.types.pointer">[[atomics.types.pointer]]</a>
 ``` cpp
 namespace std {
   template<class T> struct atomic<T*> {
     using value_type = T*;
@@ -1871,12 +1898,13 @@ pointers. Specializations of this partial specialization are
 standard-layout structs. They each have a trivial destructor.
 Descriptions are provided below only for members that differ from the
 primary template.
-The following operations perform pointer arithmetic. The key, operator,
-and computation correspondence is:
 **Table: Atomic pointer computations** <a id="atomic.types.pointer.comp">[atomic.types.pointer.comp]</a>
 |       |     |          |       |     |             |
 | ----- | --- | -------- | ----- | --- | ----------- |
@@ -1916,11 +1944,11 @@ T* operator op=(ptrdiff_t operand) noexcept;
 `is_always_lock_free` is `true`.
 *Effects:* Equivalent to:
 `return fetch_`*`key`*`(operand) `*`op`*` operand;`
-### Member operators common to integers and pointers to objects <a id="atomics.types.memop">[[atomics.types.memop]]</a>
 ``` cpp
 value_type operator++(int) volatile noexcept;
 value_type operator++(int) noexcept;
 ```
@@ -1958,26 +1986,33 @@ value_type operator--() noexcept;
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 *Effects:* Equivalent to: `return fetch_sub(1) - 1;`
-### Partial specializations for smart pointers <a id="util.smartptr.atomic">[[util.smartptr.atomic]]</a>
 The library provides partial specializations of the `atomic` template
-for shared-ownership smart pointers [[smartptr]]. The behavior of all
-operations is as specified in [[atomics.types.generic]], unless
-specified otherwise. The template parameter `T` of these partial
-specializations may be an incomplete type.
-All changes to an atomic smart pointer in this subclause, and all
-associated `use_count` increments, are guaranteed to be performed
 atomically. Associated `use_count` decrements are sequenced after the
 atomic operation, but are not required to be part of it. Any associated
 deletion and deallocation are sequenced after the atomic update step and
 are not part of the atomic operation.
-[*Note 1*: If the atomic operation uses locks, locks acquired by the
 implementation will be held when any `use_count` adjustments are
 performed, and will not be held when any destruction or deallocation
 resulting from this is performed. — *end note*]
 [*Example 1*:
@@ -1989,16 +2024,16 @@ template<typename T> class atomic_list {
     shared_ptr<node> next;
   };
   atomic<shared_ptr<node>> head;
 public:
- auto find(T t) const {
     auto p = head.load();
     while (p && p->t != t)
       p = p->next;
-    return shared_ptr<node>(move(p));
   }
   void push_front(T t) {
     auto p = make_shared<node>();
     p->t = t;
@@ -2008,21 +2043,22 @@ public:
 };
 ```
 — *end example*]
-#### Partial specialization for `shared_ptr` <a id="util.smartptr.atomic.shared">[[util.smartptr.atomic.shared]]</a>
 ``` cpp
 namespace std {
   template<class T> struct atomic<shared_ptr<T>> {
     using value_type = shared_ptr<T>;
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic type's operations are always lock free;
     bool is_lock_free() const noexcept;
     constexpr atomic() noexcept;
     atomic(shared_ptr<T> desired) noexcept;
     atomic(const atomic&) = delete;
     void operator=(const atomic&) = delete;
     shared_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
@@ -2217,11 +2253,11 @@ void notify_all() noexcept;
 are eligible to be unblocked [[atomics.wait]] by this call.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]].
-#### Partial specialization for `weak_ptr` <a id="util.smartptr.atomic.weak">[[util.smartptr.atomic.weak]]</a>
 ``` cpp
 namespace std {
   template<class T> struct atomic<weak_ptr<T>> {
     using value_type = weak_ptr<T>;
@@ -2271,11 +2307,11 @@ atomic(weak_ptr<T> desired) noexcept;
 ```
 *Effects:* Initializes the object with the value `desired`.
 Initialization is not an atomic operation [[intro.multithread]].
-[*Note 1*: It is possible to have an access to an atomic object `A`
 race with its construction, for example, by communicating the address of
 the just-constructed object `A` to another thread via
 `memory_order::relaxed` operations on a suitable atomic pointer
 variable, and then immediately accessing `A` in the receiving thread.
 This results in undefined behavior. — *end note*]
@@ -2426,11 +2462,11 @@ void notify_all() noexcept;
 are eligible to be unblocked [[atomics.wait]] by this call.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]].
-## Non-member functions <a id="atomics.nonmembers">[[atomics.nonmembers]]</a>
 A non-member function template whose name matches the pattern `atomic_f`
 or the pattern `atomic_f_explicit` invokes the member function `f`, with
 the value of the first parameter as the object expression and the values
 of the remaining parameters (if any) as the arguments of the member
@@ -2441,11 +2477,11 @@ ill-formed.
 [*Note 1*: The non-member functions enable programmers to write code
 that can be compiled as either C or C++, for example in a shared header
 file. — *end note*]
-## Flag type and operations <a id="atomics.flag">[[atomics.flag]]</a>
 ``` cpp
 namespace std {
   struct atomic_flag {
     constexpr atomic_flag() noexcept;
@@ -2471,14 +2507,12 @@ namespace std {
 ```
 The `atomic_flag` type provides the classic test-and-set functionality.
 It has two states, set and clear.
-Operations on an object of type `atomic_flag` shall be lock-free.
-[*Note 1*: Hence the operations should also be
-address-free. — *end note*]
 The `atomic_flag` type is a standard-layout struct. It has a trivial
 destructor.
 ``` cpp
@@ -2596,11 +2630,27 @@ void atomic_flag::notify_all() noexcept;
 are eligible to be unblocked [[atomics.wait]] by this call.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]].
-## Fences <a id="atomics.fences">[[atomics.fences]]</a>
 This subclause introduces synchronization primitives called *fences*.
 Fences can have acquire semantics, release semantics, or both. A fence
 with acquire semantics is called an *acquire fence*. A fence with
 release semantics is called a *release fence*.
@@ -2653,46 +2703,136 @@ which actions performed by the thread become visible to the signal
 handler. Compiler optimizations and reorderings of loads and stores are
 inhibited in the same way as with `atomic_thread_fence`, but the
 hardware fence instructions that `atomic_thread_fence` would have
 inserted are not emitted. — *end note*]
-<!-- Link reference definitions -->
-[atomic.types.int.comp]: #atomic.types.int.comp
-[atomic.types.pointer.comp]: #atomic.types.pointer.comp
-[atomics]: #atomics
-[atomics.alias]: #atomics.alias
-[atomics.fences]: #atomics.fences
-[atomics.flag]: #atomics.flag
-[atomics.general]: #atomics.general
-[atomics.lockfree]: #atomics.lockfree
-[atomics.nonmembers]: #atomics.nonmembers
-[atomics.order]: #atomics.order
-[atomics.ref.float]: #atomics.ref.float
-[atomics.ref.generic]: #atomics.ref.generic
-[atomics.ref.int]: #atomics.ref.int
-[atomics.ref.memop]: #atomics.ref.memop
-[atomics.ref.ops]: #atomics.ref.ops
-[atomics.ref.pointer]: #atomics.ref.pointer
-[atomics.summary]: #atomics.summary
-[atomics.syn]: #atomics.syn
-[atomics.types.float]: #atomics.types.float
-[atomics.types.generic]: #atomics.types.generic
-[atomics.types.int]: #atomics.types.int
-[atomics.types.memop]: #atomics.types.memop
-[atomics.types.operations]: #atomics.types.operations
-[atomics.types.pointer]: #atomics.types.pointer
-[atomics.wait]: #atomics.wait
-[basic.align]: basic.md#basic.align
-[basic.fundamental]: basic.md#basic.fundamental
-[basic.life]: basic.md#basic.life
-[basic.types]: basic.md#basic.types
-[cfenv]: numerics.md#cfenv
-[compliance]: library.md#compliance
-[expr.pre]: expr.md#expr.pre
-[intro.multithread]: basic.md#intro.multithread
-[intro.progress]: basic.md#intro.progress
-[intro.races]: basic.md#intro.races
-[limits.syn]: support.md#limits.syn
-[smartptr]: utilities.md#smartptr
-[util.smartptr.atomic]: #util.smartptr.atomic
-[util.smartptr.atomic.shared]: #util.smartptr.atomic.shared
-[util.smartptr.atomic.weak]: #util.smartptr.atomic.weak

+## Atomic operations <a id="atomics">[[atomics]]</a>
+### General <a id="atomics.general">[[atomics.general]]</a>
+Subclause [[atomics]] describes components for fine-grained atomic
+access. This access is provided via operations on atomic objects.
+### Header `<atomic>` synopsis <a id="atomics.syn">[[atomics.syn]]</a>
 ``` cpp
 namespace std {
   // [atomics.order], order and consistency
+  enum class memory_order : unspecified;                                            // freestanding
+  inline constexpr memory_order memory_order_relaxed = memory_order::relaxed;       // freestanding
+  inline constexpr memory_order memory_order_consume = memory_order::consume;       // freestanding
+  inline constexpr memory_order memory_order_acquire = memory_order::acquire;       // freestanding
+  inline constexpr memory_order memory_order_release = memory_order::release;       // freestanding
+  inline constexpr memory_order memory_order_acq_rel = memory_order::acq_rel;       // freestanding
+  inline constexpr memory_order memory_order_seq_cst = memory_order::seq_cst;       // freestanding
   template<class T>
+    T kill_dependency(T y) noexcept;                                                // freestanding
+}
 // [atomics.lockfree], lock-free property
+#define ATOMIC_BOOL_LOCK_FREE unspecified                                           // freestanding
+#define ATOMIC_CHAR_LOCK_FREE unspecified                                           // freestanding
+#define ATOMIC_CHAR8_T_LOCK_FREE unspecified                                        // freestanding
+#define ATOMIC_CHAR16_T_LOCK_FREE unspecified                                       // freestanding
+#define ATOMIC_CHAR32_T_LOCK_FREE unspecified                                       // freestanding
+#define ATOMIC_WCHAR_T_LOCK_FREE unspecified                                        // freestanding
+#define ATOMIC_SHORT_LOCK_FREE unspecified                                          // freestanding
+#define ATOMIC_INT_LOCK_FREE unspecified                                            // freestanding
+#define ATOMIC_LONG_LOCK_FREE unspecified                                           // freestanding
+#define ATOMIC_LLONG_LOCK_FREE unspecified                                          // freestanding
+#define ATOMIC_POINTER_LOCK_FREE unspecified                                        // freestanding
+namespace std {
   // [atomics.ref.generic], class template atomic_ref
+  template<class T> struct atomic_ref;                                              // freestanding
   // [atomics.ref.pointer], partial specialization for pointers
+  template<class T> struct atomic_ref<T*>;                                          // freestanding
   // [atomics.types.generic], class template atomic
+  template<class T> struct atomic;                                                  // freestanding
   // [atomics.types.pointer], partial specialization for pointers
+  template<class T> struct atomic<T*>;                                              // freestanding
   // [atomics.nonmembers], non-member functions
   template<class T>
+    bool atomic_is_lock_free(const volatile atomic<T>*) noexcept;                   // freestanding
   template<class T>
+    bool atomic_is_lock_free(const atomic<T>*) noexcept;                            // freestanding
   template<class T>
+    void atomic_store(volatile atomic<T>*,                                          // freestanding
+                      typename atomic<T>::value_type) noexcept;
   template<class T>
+    void atomic_store(atomic<T>*, typename atomic<T>::value_type) noexcept;         // freestanding
   template<class T>
+    void atomic_store_explicit(volatile atomic<T>*,                                 // freestanding
+                               typename atomic<T>::value_type,
                                memory_order) noexcept;
   template<class T>
+    void atomic_store_explicit(atomic<T>*, typename atomic<T>::value_type,          // freestanding
                                memory_order) noexcept;
   template<class T>
+    T atomic_load(const volatile atomic<T>*) noexcept;                              // freestanding
   template<class T>
+    T atomic_load(const atomic<T>*) noexcept;                                       // freestanding
   template<class T>
+    T atomic_load_explicit(const volatile atomic<T>*, memory_order) noexcept;       // freestanding
   template<class T>
+    T atomic_load_explicit(const atomic<T>*, memory_order) noexcept;                // freestanding
   template<class T>
+    T atomic_exchange(volatile atomic<T>*,                                          // freestanding
+                      typename atomic<T>::value_type) noexcept;
   template<class T>
+    T atomic_exchange(atomic<T>*, typename atomic<T>::value_type) noexcept;         // freestanding
   template<class T>
+    T atomic_exchange_explicit(volatile atomic<T>*,                                 // freestanding
+                               typename atomic<T>::value_type,
                                memory_order) noexcept;
   template<class T>
+    T atomic_exchange_explicit(atomic<T>*, typename atomic<T>::value_type,          // freestanding
                                memory_order) noexcept;
   template<class T>
+    bool atomic_compare_exchange_weak(volatile atomic<T>*,                          // freestanding
                                       typename atomic<T>::value_type*,
                                       typename atomic<T>::value_type) noexcept;
   template<class T>
+    bool atomic_compare_exchange_weak(atomic<T>*,                                   // freestanding
                                       typename atomic<T>::value_type*,
                                       typename atomic<T>::value_type) noexcept;
   template<class T>
+    bool atomic_compare_exchange_strong(volatile atomic<T>*,                        // freestanding
                                         typename atomic<T>::value_type*,
                                         typename atomic<T>::value_type) noexcept;
   template<class T>
+    bool atomic_compare_exchange_strong(atomic<T>*,                                 // freestanding
                                         typename atomic<T>::value_type*,
                                         typename atomic<T>::value_type) noexcept;
   template<class T>
+    bool atomic_compare_exchange_weak_explicit(volatile atomic<T>*,                 // freestanding
                                                typename atomic<T>::value_type*,
                                                typename atomic<T>::value_type,
                                                memory_order, memory_order) noexcept;
   template<class T>
+    bool atomic_compare_exchange_weak_explicit(atomic<T>*,                          // freestanding
                                                typename atomic<T>::value_type*,
                                                typename atomic<T>::value_type,
                                                memory_order, memory_order) noexcept;
   template<class T>
+    bool atomic_compare_exchange_strong_explicit(volatile atomic<T>*,               // freestanding
                                                  typename atomic<T>::value_type*,
                                                  typename atomic<T>::value_type,
                                                  memory_order, memory_order) noexcept;
   template<class T>
+    bool atomic_compare_exchange_strong_explicit(atomic<T>*,                        // freestanding
                                                  typename atomic<T>::value_type*,
                                                  typename atomic<T>::value_type,
                                                  memory_order, memory_order) noexcept;
   template<class T>
+    T atomic_fetch_add(volatile atomic<T>*,                                         // freestanding
+                       typename atomic<T>::difference_type) noexcept;
   template<class T>
+    T atomic_fetch_add(atomic<T>*, typename atomic<T>::difference_type) noexcept;   // freestanding
   template<class T>
+    T atomic_fetch_add_explicit(volatile atomic<T>*,                                // freestanding
+                                typename atomic<T>::difference_type,
                                 memory_order) noexcept;
   template<class T>
+    T atomic_fetch_add_explicit(atomic<T>*, typename atomic<T>::difference_type,    // freestanding
                                 memory_order) noexcept;
   template<class T>
+    T atomic_fetch_sub(volatile atomic<T>*,                                         // freestanding
+                       typename atomic<T>::difference_type) noexcept;
   template<class T>
+    T atomic_fetch_sub(atomic<T>*, typename atomic<T>::difference_type) noexcept;   // freestanding
   template<class T>
+    T atomic_fetch_sub_explicit(volatile atomic<T>*,                                // freestanding
+                                typename atomic<T>::difference_type,
                                 memory_order) noexcept;
   template<class T>
+    T atomic_fetch_sub_explicit(atomic<T>*, typename atomic<T>::difference_type,    // freestanding
                                 memory_order) noexcept;
   template<class T>
+    T atomic_fetch_and(volatile atomic<T>*,                                         // freestanding
+                       typename atomic<T>::value_type) noexcept;
   template<class T>
+    T atomic_fetch_and(atomic<T>*, typename atomic<T>::value_type) noexcept;        // freestanding
   template<class T>
+    T atomic_fetch_and_explicit(volatile atomic<T>*,                                // freestanding
+                                typename atomic<T>::value_type,
                                 memory_order) noexcept;
   template<class T>
+    T atomic_fetch_and_explicit(atomic<T>*, typename atomic<T>::value_type,         // freestanding
                                 memory_order) noexcept;
   template<class T>
+    T atomic_fetch_or(volatile atomic<T>*,                                          // freestanding
+                      typename atomic<T>::value_type) noexcept;
   template<class T>
+    T atomic_fetch_or(atomic<T>*, typename atomic<T>::value_type) noexcept;         // freestanding
   template<class T>
+    T atomic_fetch_or_explicit(volatile atomic<T>*,                                 // freestanding
+                               typename atomic<T>::value_type,
                                memory_order) noexcept;
   template<class T>
+    T atomic_fetch_or_explicit(atomic<T>*, typename atomic<T>::value_type,          // freestanding
                                memory_order) noexcept;
   template<class T>
+    T atomic_fetch_xor(volatile atomic<T>*,                                         // freestanding
+                       typename atomic<T>::value_type) noexcept;
   template<class T>
+    T atomic_fetch_xor(atomic<T>*, typename atomic<T>::value_type) noexcept;        // freestanding
   template<class T>
+    T atomic_fetch_xor_explicit(volatile atomic<T>*,                                // freestanding
+                                typename atomic<T>::value_type,
                                 memory_order) noexcept;
   template<class T>
+    T atomic_fetch_xor_explicit(atomic<T>*, typename atomic<T>::value_type,         // freestanding
                                 memory_order) noexcept;
   template<class T>
+    void atomic_wait(const volatile atomic<T>*,                                     // freestanding
+                 typename atomic<T>::value_type) noexcept;
   template<class T>
+    void atomic_wait(const atomic<T>*, typename atomic<T>::value_type) noexcept;    // freestanding
   template<class T>
+    void atomic_wait_explicit(const volatile atomic<T>*,                            // freestanding
+ typename atomic<T>::value_type,
+                              memory_order) noexcept;
   template<class T>
+    void atomic_wait_explicit(const atomic<T>*, typename atomic<T>::value_type,     // freestanding
+                              memory_order) noexcept;
   template<class T>
+    void atomic_notify_one(volatile atomic<T>*) noexcept;                           // freestanding
   template<class T>
+    void atomic_notify_one(atomic<T>*) noexcept;                                    // freestanding
   template<class T>
+    void atomic_notify_all(volatile atomic<T>*) noexcept;                           // freestanding
   template<class T>
+    void atomic_notify_all(atomic<T>*) noexcept;                                    // freestanding
   // [atomics.alias], type aliases
+  using atomic_bool           = atomic<bool>;                                       // freestanding
+  using atomic_char           = atomic<char>;                                       // freestanding
+  using atomic_schar          = atomic<signed char>;                                // freestanding
+  using atomic_uchar          = atomic<unsigned char>;                              // freestanding
+  using atomic_short          = atomic<short>;                                      // freestanding
+  using atomic_ushort         = atomic<unsigned short>;                             // freestanding
+  using atomic_int            = atomic<int>;                                        // freestanding
+  using atomic_uint           = atomic<unsigned int>;                               // freestanding
+  using atomic_long           = atomic<long>;                                       // freestanding
+  using atomic_ulong          = atomic<unsigned long>;                              // freestanding
+  using atomic_llong          = atomic<long long>;                                  // freestanding
+  using atomic_ullong         = atomic<unsigned long long>;                         // freestanding
+  using atomic_char8_t        = atomic<char8_t>;                                    // freestanding
+  using atomic_char16_t       = atomic<char16_t>;                                   // freestanding
+  using atomic_char32_t       = atomic<char32_t>;                                   // freestanding
+  using atomic_wchar_t        = atomic<wchar_t>;                                    // freestanding
+  using atomic_int8_t         = atomic<int8_t>;                                     // freestanding
+  using atomic_uint8_t        = atomic<uint8_t>;                                    // freestanding
+  using atomic_int16_t        = atomic<int16_t>;                                    // freestanding
+  using atomic_uint16_t       = atomic<uint16_t>;                                   // freestanding
+  using atomic_int32_t        = atomic<int32_t>;                                    // freestanding
+  using atomic_uint32_t       = atomic<uint32_t>;                                   // freestanding
+  using atomic_int64_t        = atomic<int64_t>;                                    // freestanding
+  using atomic_uint64_t       = atomic<uint64_t>;                                   // freestanding
+  using atomic_int_least8_t   = atomic<int_least8_t>;                               // freestanding
+  using atomic_uint_least8_t  = atomic<uint_least8_t>;                              // freestanding
+  using atomic_int_least16_t  = atomic<int_least16_t>;                              // freestanding
+  using atomic_uint_least16_t = atomic<uint_least16_t>;                             // freestanding
+  using atomic_int_least32_t  = atomic<int_least32_t>;                              // freestanding
+  using atomic_uint_least32_t = atomic<uint_least32_t>;                             // freestanding
+  using atomic_int_least64_t  = atomic<int_least64_t>;                              // freestanding
+  using atomic_uint_least64_t = atomic<uint_least64_t>;                             // freestanding
+  using atomic_int_fast8_t    = atomic<int_fast8_t>;                                // freestanding
+  using atomic_uint_fast8_t   = atomic<uint_fast8_t>;                               // freestanding
+  using atomic_int_fast16_t   = atomic<int_fast16_t>;                               // freestanding
+  using atomic_uint_fast16_t  = atomic<uint_fast16_t>;                              // freestanding
+  using atomic_int_fast32_t   = atomic<int_fast32_t>;                               // freestanding
+  using atomic_uint_fast32_t  = atomic<uint_fast32_t>;                              // freestanding
+  using atomic_int_fast64_t   = atomic<int_fast64_t>;                               // freestanding
+  using atomic_uint_fast64_t  = atomic<uint_fast64_t>;                              // freestanding
+  using atomic_intptr_t       = atomic<intptr_t>;                                   // freestanding
+  using atomic_uintptr_t      = atomic<uintptr_t>;                                  // freestanding
+  using atomic_size_t         = atomic<size_t>;                                     // freestanding
+  using atomic_ptrdiff_t      = atomic<ptrdiff_t>;                                  // freestanding
+  using atomic_intmax_t       = atomic<intmax_t>;                                   // freestanding
+  using atomic_uintmax_t      = atomic<uintmax_t>;                                  // freestanding
   using atomic_signed_lock_free   = see below;
   using atomic_unsigned_lock_free = see below;
   // [atomics.flag], flag type and operations
+  struct atomic_flag;                                                               // freestanding
+  bool atomic_flag_test(const volatile atomic_flag*) noexcept;                      // freestanding
+  bool atomic_flag_test(const atomic_flag*) noexcept;                               // freestanding
+  bool atomic_flag_test_explicit(const volatile atomic_flag*,                       // freestanding
+ memory_order) noexcept;
+  bool atomic_flag_test_explicit(const atomic_flag*, memory_order) noexcept;        // freestanding
+  bool atomic_flag_test_and_set(volatile atomic_flag*) noexcept;                    // freestanding
+  bool atomic_flag_test_and_set(atomic_flag*) noexcept;                             // freestanding
+  bool atomic_flag_test_and_set_explicit(volatile atomic_flag*,                     // freestanding
+                                         memory_order) noexcept;
+ bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order) noexcept;      // freestanding
+  void atomic_flag_clear(volatile atomic_flag*) noexcept;                           // freestanding
+  void atomic_flag_clear(atomic_flag*) noexcept;                                    // freestanding
+  void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order) noexcept;    // freestanding
+  void atomic_flag_clear_explicit(atomic_flag*, memory_order) noexcept;             // freestanding
+  void atomic_flag_wait(const volatile atomic_flag*, bool) noexcept;                // freestanding
+  void atomic_flag_wait(const atomic_flag*, bool) noexcept;                         // freestanding
+  void atomic_flag_wait_explicit(const volatile atomic_flag*,                       // freestanding
                                  bool, memory_order) noexcept;
+  void atomic_flag_wait_explicit(const atomic_flag*,                                // freestanding
                                  bool, memory_order) noexcept;
+  void atomic_flag_notify_one(volatile atomic_flag*) noexcept;                      // freestanding
+  void atomic_flag_notify_one(atomic_flag*) noexcept;                               // freestanding
+  void atomic_flag_notify_all(volatile atomic_flag*) noexcept;                      // freestanding
+  void atomic_flag_notify_all(atomic_flag*) noexcept;                               // freestanding
+  #define ATOMIC_FLAG_INIT see belownc                                                // freestanding
   // [atomics.fences], fences
+  extern "C" void atomic_thread_fence(memory_order) noexcept;                       // freestanding
+  extern "C" void atomic_signal_fence(memory_order) noexcept;                       // freestanding
 }
 ```
+### Type aliases <a id="atomics.alias">[[atomics.alias]]</a>
 The type aliases `atomic_intN_t`, `atomic_uintN_t`, `atomic_intptr_t`,
 and `atomic_uintptr_t` are defined if and only if `intN_t`, `uintN_t`,
 `intptr_t`, and `uintptr_t` are defined, respectively.
 Implementations should choose for these aliases the integral
 specializations of `atomic` for which the atomic waiting and notifying
 operations [[atomics.wait]] are most efficient.
+### Order and consistency <a id="atomics.order">[[atomics.order]]</a>
 ``` cpp
 namespace std {
   enum class memory_order : unspecified {
     relaxed, consume, acquire, release, acq_rel, seq_cst
   };
 }
 ```
 The enumeration `memory_order` specifies the detailed regular
 (non-atomic) memory synchronization order as defined in
 // Thread 2:
 r2 = x.load(memory_order::relaxed);
 y.store(r2, memory_order::relaxed);
 ```
+this recommendation discourages producing `r1 == r2 == 42`, since the
+store of 42 to `y` is only possible if the store to `x` stores `42`,
+which circularly depends on the store to `y` storing `42`. Note that
+without this restriction, such an execution is possible.
 — *end note*]
 [*Note 7*:
 *Effects:* The argument does not carry a dependency to the return
 value [[intro.multithread]].
 *Returns:* `y`.
+### Lock-free property <a id="atomics.lockfree">[[atomics.lockfree]]</a>
 ``` cpp
 #define ATOMIC_BOOL_LOCK_FREE unspecified
 #define ATOMIC_CHAR_LOCK_FREE unspecified
 #define ATOMIC_CHAR8_T_LOCK_FREE unspecified
 (partial) specializations of the `atomic` template. A value of 0
 indicates that the types are never lock-free. A value of 1 indicates
 that the types are sometimes lock-free. A value of 2 indicates that the
 types are always lock-free.
+On a hosted implementation [[compliance]], at least one signed integral
+specialization of the `atomic` template, along with the specialization
+for the corresponding unsigned type [[basic.fundamental]], is always
+lock-free.
+The functions `atomic<T>::is_lock_free` and `atomic_is_lock_free`
+[[atomics.types.operations]] indicate whether the object is lock-free.
+In any given program execution, the result of the lock-free query is the
+same for all atomic objects of the same type.
 Atomic operations that are not lock-free are considered to potentially
 block [[intro.progress]].
+*Recommended practice:* Operations that are lock-free should also be
+address-free.[^2]
+The implementation of these operations should not depend on any
+per-process state.
+[*Note 1*: This restriction enables communication by memory that is
+mapped into a process more than once and by memory that is shared
+between two processes. — *end note*]
+### Waiting and notifying <a id="atomics.wait">[[atomics.wait]]</a>
 *Atomic waiting operations* and *atomic notifying operations* provide a
 mechanism to wait for the value of an atomic object to change more
 efficiently than can be achieved with polling. An atomic waiting
 operation may block until it is unblocked by an atomic notifying
 - the atomic waiting operation has blocked after observing the result of
   `X`,
 - `X` precedes `Y` in the modification order of `M`, and
 - `Y` happens before the call to the atomic notifying operation.
+### Class template `atomic_ref` <a id="atomics.ref.generic">[[atomics.ref.generic]]</a>
+#### General <a id="atomics.ref.generic.general">[[atomics.ref.generic.general]]</a>
 ``` cpp
 namespace std {
   template<class T> struct atomic_ref {
   private:
     T* ptr;             // exposition only
   public:
     using value_type = T;
     static constexpr size_t required_alignment = implementation-defined  // required alignment for atomic_ref type's operations;
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic_ref type's operations are always lock free;
 Atomic operations applied to an object through a referencing
 `atomic_ref` are atomic with respect to atomic operations applied
 through any other `atomic_ref` referencing the same object.
+[*Note 1*: Atomic operations or the `atomic_ref` constructor can
 acquire a shared resource, such as a lock associated with the referenced
 object, to enable atomic operations to be applied to the referenced
 object. — *end note*]
+#### Operations <a id="atomics.ref.ops">[[atomics.ref.ops]]</a>
 ``` cpp
 static constexpr size_t required_alignment;
 ```
 `*ptr` that are eligible to be unblocked [[atomics.wait]] by this call.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]] on atomic object `*ptr`.
+#### Specializations for integral types <a id="atomics.ref.int">[[atomics.ref.int]]</a>
 There are specializations of the `atomic_ref` class template for the
 integral types `char`, `signed char`, `unsigned char`, `short`,
 `unsigned short`, `int`, `unsigned int`, `long`, `unsigned long`,
 `long long`, `unsigned long long`, `char8_t`, `char16_t`, `char32_t`,
 `wchar_t`, and any other types needed by the typedefs in the header
+`<cstdint>`. For each such type `integral-type`, the specialization
+`atomic_ref<integral-type>` provides additional atomic operations
+appropriate to integral types.
 [*Note 1*: The specialization `atomic_ref<bool>` uses the primary
 template [[atomics.ref.generic]]. — *end note*]
 ``` cpp
 namespace std {
+  template<> struct atomic_ref<integral-type> {
   private:
+    integral-type* ptr; // exposition only
   public:
+    using value_type = integral-type;
     using difference_type = value_type;
     static constexpr size_t required_alignment = implementation-defined  // required alignment for atomic_ref type's operations;
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic_ref type's operations are always lock free;
     bool is_lock_free() const noexcept;
+    explicit atomic_ref(integral-type&);
     atomic_ref(const atomic_ref&) noexcept;
     atomic_ref& operator=(const atomic_ref&) = delete;
+    void store(integral-type, memory_order = memory_order::seq_cst) const noexcept;
+    integral-type operator=(integral-type) const noexcept;
+    integral-type load(memory_order = memory_order::seq_cst) const noexcept;
+    operator integral-type() const noexcept;
+    integral-type exchange(integral-type,
                            memory_order = memory_order::seq_cst) const noexcept;
+    bool compare_exchange_weak(integral-type&, integral-type,
                                memory_order, memory_order) const noexcept;
+    bool compare_exchange_strong(integral-type&, integral-type,
                                  memory_order, memory_order) const noexcept;
+    bool compare_exchange_weak(integral-type&, integral-type,
                                memory_order = memory_order::seq_cst) const noexcept;
+    bool compare_exchange_strong(integral-type&, integral-type,
                                  memory_order = memory_order::seq_cst) const noexcept;
+    integral-type fetch_add(integral-type,
                             memory_order = memory_order::seq_cst) const noexcept;
+    integral-type fetch_sub(integral-type,
                             memory_order = memory_order::seq_cst) const noexcept;
+    integral-type fetch_and(integral-type,
                             memory_order = memory_order::seq_cst) const noexcept;
+    integral-type fetch_or(integral-type,
                             memory_order = memory_order::seq_cst) const noexcept;
+    integral-type fetch_xor(integral-type,
                             memory_order = memory_order::seq_cst) const noexcept;
+    integral-type operator++(int) const noexcept;
+    integral-type operator--(int) const noexcept;
+    integral-type operator++() const noexcept;
+    integral-type operator--() const noexcept;
+    integral-type operator+=(integral-type) const noexcept;
+    integral-type operator-=(integral-type) const noexcept;
+    integral-type operator&=(integral-type) const noexcept;
+    integral-type operator|=(integral-type) const noexcept;
+    integral-type operator^=(integral-type) const noexcept;
+    void wait(integral-type, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() const noexcept;
     void notify_all() const noexcept;
   };
 }
 ```
 Descriptions are provided below only for members that differ from the
 primary template.
+The following operations perform arithmetic computations. The
+correspondence among key, operator, and computation is specified in
 [[atomic.types.int.comp]].
 ``` cpp
+integral-type fetch_key(integral-type operand,
+  memory_order order = memory_order::seq_cst) const noexcept;
 ```
 *Effects:* Atomically replaces the value referenced by `*ptr` with the
 result of the computation applied to the value referenced by `*ptr` and
 the given operand. Memory is affected according to the value of `order`.
 [*Note 1*: There are no undefined results arising from the
 computation. — *end note*]
 ``` cpp
+integral-type operator op=(integral-type operand) const noexcept;
 ```
 *Effects:* Equivalent to:
 `return fetch_`*`key`*`(operand) `*`op`*` operand;`
+#### Specializations for floating-point types <a id="atomics.ref.float">[[atomics.ref.float]]</a>
+There are specializations of the `atomic_ref` class template for all
+cv-unqualified floating-point types. For each such type
+`floating-point-type`, the specialization `atomic_ref<floating-point>`
 provides additional atomic operations appropriate to floating-point
 types.
 ``` cpp
 namespace std {
+  template<> struct atomic_ref<floating-point-type> {
   private:
+    floating-point-type* ptr; // exposition only
   public:
+    using value_type = floating-point-type;
     using difference_type = value_type;
     static constexpr size_t required_alignment = implementation-defined  // required alignment for atomic_ref type's operations;
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic_ref type's operations are always lock free;
     bool is_lock_free() const noexcept;
+    explicit atomic_ref(floating-point-type&);
     atomic_ref(const atomic_ref&) noexcept;
     atomic_ref& operator=(const atomic_ref&) = delete;
+    void store(floating-point-type, memory_order = memory_order::seq_cst) const noexcept;
+    floating-point-type operator=(floating-point-type) const noexcept;
+    floating-point-type load(memory_order = memory_order::seq_cst) const noexcept;
+    operator floating-point-type() const noexcept;
+    floating-point-type exchange(floating-point-type,
                                  memory_order = memory_order::seq_cst) const noexcept;
+    bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                memory_order, memory_order) const noexcept;
+    bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                  memory_order, memory_order) const noexcept;
+    bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                memory_order = memory_order::seq_cst) const noexcept;
+    bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                  memory_order = memory_order::seq_cst) const noexcept;
+    floating-point-type fetch_add(floating-point-type,
                                   memory_order = memory_order::seq_cst) const noexcept;
+    floating-point-type fetch_sub(floating-point-type,
                                   memory_order = memory_order::seq_cst) const noexcept;
+    floating-point-type operator+=(floating-point-type) const noexcept;
+    floating-point-type operator-=(floating-point-type) const noexcept;
+    void wait(floating-point-type, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() const noexcept;
     void notify_all() const noexcept;
   };
 }
 ```
 Descriptions are provided below only for members that differ from the
 primary template.
+The following operations perform arithmetic computations. The
+correspondence among key, operator, and computation is specified in
 [[atomic.types.int.comp]].
 ``` cpp
+floating-point-type fetch_key(floating-point-type operand,
                           memory_order order = memory_order::seq_cst) const noexcept;
 ```
 *Effects:* Atomically replaces the value referenced by `*ptr` with the
 result of the computation applied to the value referenced by `*ptr` and
 the effects.
 *Remarks:* If the result is not a representable value for its
 type [[expr.pre]], the result is unspecified, but the operations
 otherwise have no undefined behavior. Atomic arithmetic operations on
+*`floating-point-type`* should conform to the
+`std::numeric_limits<`*`floating-point-type`*`>` traits associated with
+the floating-point type [[limits.syn]]. The floating-point
 environment [[cfenv]] for atomic arithmetic operations on
+*`floating-point-type`* may be different than the calling thread’s
 floating-point environment.
 ``` cpp
+floating-point-type operator op=(floating-point-type operand) const noexcept;
 ```
 *Effects:* Equivalent to:
 `return fetch_`*`key`*`(operand) `*`op`*` operand;`
+#### Partial specialization for pointers <a id="atomics.ref.pointer">[[atomics.ref.pointer]]</a>
 ``` cpp
 namespace std {
   template<class T> struct atomic_ref<T*> {
   private:
     T** ptr;        // exposition only
   public:
     using value_type = T*;
     using difference_type = ptrdiff_t;
     static constexpr size_t required_alignment = implementation-defined  // required alignment for atomic_ref type's operations;
 ```
 Descriptions are provided below only for members that differ from the
 primary template.
+The following operations perform arithmetic computations. The
+correspondence among key, operator, and computation is specified in
 [[atomic.types.pointer.comp]].
 ``` cpp
 T* fetch_key(difference_type operand, memory_order order = memory_order::seq_cst) const noexcept;
 ```
 ```
 *Effects:* Equivalent to:
 `return fetch_`*`key`*`(operand) `*`op`*` operand;`
+#### Member operators common to integers and pointers to objects <a id="atomics.ref.memop">[[atomics.ref.memop]]</a>
 ``` cpp
 value_type operator++(int) const noexcept;
 ```
 value_type operator--() const noexcept;
 ```
 *Effects:* Equivalent to: `return fetch_sub(1) - 1;`
+### Class template `atomic` <a id="atomics.types.generic">[[atomics.types.generic]]</a>
+#### General <a id="atomics.types.generic.general">[[atomics.types.generic.general]]</a>
 ``` cpp
 namespace std {
   template<class T> struct atomic {
     using value_type = T;
 - `is_move_assignable_v<T>`
 is `false`.
 [*Note 1*: Type arguments that are not also statically initializable
+can be difficult to use. — *end note*]
 The specialization `atomic<bool>` is a standard-layout struct.
 [*Note 2*: The representation of an atomic specialization need not have
 the same size and alignment requirement as its corresponding argument
 type. — *end note*]
+#### Operations on atomic types <a id="atomics.types.operations">[[atomics.types.operations]]</a>
 ``` cpp
 constexpr atomic() noexcept(is_nothrow_default_constructible_v<T>);
 ```
 ``` cpp
 void store(T desired, memory_order order = memory_order::seq_cst) volatile noexcept;
 void store(T desired, memory_order order = memory_order::seq_cst) noexcept;
 ```
+*Constraints:* For the `volatile` overload of this function,
+`is_always_lock_free` is `true`.
 *Preconditions:* The `order` argument is neither
 `memory_order::consume`, `memory_order::acquire`, nor
 `memory_order::acq_rel`.
 *Effects:* Atomically replaces the value pointed to by `this` with the
 value of `desired`. Memory is affected according to the value of
 `order`.
 ``` cpp
 ``` cpp
 T load(memory_order order = memory_order::seq_cst) const volatile noexcept;
 T load(memory_order order = memory_order::seq_cst) const noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
+*Preconditions:* The `order` argument is neither `memory_order::release`
+nor `memory_order::acq_rel`.
 *Effects:* Memory is affected according to the value of `order`.
 *Returns:* Atomically returns the value pointed to by `this`.
 ``` cpp
                              memory_order order = memory_order::seq_cst) volatile noexcept;
 bool compare_exchange_strong(T& expected, T desired,
                              memory_order order = memory_order::seq_cst) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
+*Preconditions:* The `failure` argument is neither
+`memory_order::release` nor `memory_order::acq_rel`.
 *Effects:* Retrieves the value in `expected`. It then atomically
 compares the value representation of the value pointed to by `this` for
 equality with that previously retrieved from `expected`, and if true,
 replaces the value pointed to by `this` with that in `desired`. If and
 only if the comparison is `true`, memory is affected according to the
 *Returns:* The result of the comparison.
 [*Note 4*:
 For example, the effect of `compare_exchange_strong` on objects without
+padding bits [[term.padding.bits]] is
 ``` cpp
 if (memcmp(this, &expected, sizeof(*this)) == 0)
   memcpy(this, &desired, sizeof(*this));
 else
+  memcpy(&expected, this, sizeof(*this));
 ```
 — *end note*]
 [*Example 1*:
 performance on some platforms. When a weak compare-and-exchange would
 require a loop and a strong one would not, the strong one is
 preferable. — *end note*]
 [*Note 6*: Under cases where the `memcpy` and `memcmp` semantics of the
+compare-and-exchange operations apply, the comparisons can fail for
+values that compare equal with `operator==` if the value representation
+has trap bits or alternate representations of the same value. Notably,
+on implementations conforming to ISO/IEC/IEEE 60559, floating-point
+`-0.0` and `+0.0` will not compare equal with `memcmp` but will compare
+equal with `operator==`, and NaNs with the same payload will compare
+equal with `memcmp` but will not compare equal with
 `operator==`. — *end note*]
 [*Note 7*:
 Because compare-and-exchange acts on an object’s value representation,
 are eligible to be unblocked [[atomics.wait]] by this call.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]].
+#### Specializations for integers <a id="atomics.types.int">[[atomics.types.int]]</a>
 There are specializations of the `atomic` class template for the
 integral types `char`, `signed char`, `unsigned char`, `short`,
 `unsigned short`, `int`, `unsigned int`, `long`, `unsigned long`,
 `long long`, `unsigned long long`, `char8_t`, `char16_t`, `char32_t`,
 `wchar_t`, and any other types needed by the typedefs in the header
+`<cstdint>`. For each such type `integral-type`, the specialization
+`atomic<integral-type>` provides additional atomic operations
+appropriate to integral types.
 [*Note 1*: The specialization `atomic<bool>` uses the primary template
 [[atomics.types.generic]]. — *end note*]
 ``` cpp
 namespace std {
+  template<> struct atomic<integral-type> {
+    using value_type = integral-type;
     using difference_type = value_type;
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic type's operations are always lock free;
     bool is_lock_free() const volatile noexcept;
     bool is_lock_free() const noexcept;
     constexpr atomic() noexcept;
+    constexpr atomic(integral-type) noexcept;
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
+    void store(integral-type, memory_order = memory_order::seq_cst) volatile noexcept;
+    void store(integral-type, memory_order = memory_order::seq_cst) noexcept;
+    integral-type operator=(integral-type) volatile noexcept;
+    integral-type operator=(integral-type) noexcept;
+    integral-type load(memory_order = memory_order::seq_cst) const volatile noexcept;
+    integral-type load(memory_order = memory_order::seq_cst) const noexcept;
+    operator integral-type() const volatile noexcept;
+    operator integral-type() const noexcept;
+    integral-type exchange(integral-type,
+ memory_order = memory_order::seq_cst) volatile noexcept;
+ integral-type exchange(integral-type,
+                           memory_order = memory_order::seq_cst) noexcept;
+    bool compare_exchange_weak(integral-type&, integral-type,
                                memory_order, memory_order) volatile noexcept;
+    bool compare_exchange_weak(integral-type&, integral-type,
                                memory_order, memory_order) noexcept;
+    bool compare_exchange_strong(integral-type&, integral-type,
                                  memory_order, memory_order) volatile noexcept;
+    bool compare_exchange_strong(integral-type&, integral-type,
                                  memory_order, memory_order) noexcept;
+    bool compare_exchange_weak(integral-type&, integral-type,
                                memory_order = memory_order::seq_cst) volatile noexcept;
+    bool compare_exchange_weak(integral-type&, integral-type,
                                memory_order = memory_order::seq_cst) noexcept;
+    bool compare_exchange_strong(integral-type&, integral-type,
                                  memory_order = memory_order::seq_cst) volatile noexcept;
+    bool compare_exchange_strong(integral-type&, integral-type,
                                  memory_order = memory_order::seq_cst) noexcept;
+    integral-type fetch_add(integral-type,
+ memory_order = memory_order::seq_cst) volatile noexcept;
+    integral-type fetch_add(integral-type,
+ memory_order = memory_order::seq_cst) noexcept;
+    integral-type fetch_sub(integral-type,
+ memory_order = memory_order::seq_cst) volatile noexcept;
+    integral-type fetch_sub(integral-type,
+ memory_order = memory_order::seq_cst) noexcept;
+    integral-type fetch_and(integral-type,
+ memory_order = memory_order::seq_cst) volatile noexcept;
+    integral-type fetch_and(integral-type,
+                            memory_order = memory_order::seq_cst) noexcept;
+    integral-type fetch_or(integral-type,
+                            memory_order = memory_order::seq_cst) volatile noexcept;
+    integral-type fetch_or(integral-type,
+                            memory_order = memory_order::seq_cst) noexcept;
+    integral-type fetch_xor(integral-type,
+                            memory_order = memory_order::seq_cst) volatile noexcept;
+    integral-type fetch_xor(integral-type,
+                            memory_order = memory_order::seq_cst) noexcept;
+    integral-type operator++(int) volatile noexcept;
+    integral-type operator++(int) noexcept;
+    integral-type operator--(int) volatile noexcept;
+    integral-type operator--(int) noexcept;
+    integral-type operator++() volatile noexcept;
+    integral-type operator++() noexcept;
+    integral-type operator--() volatile noexcept;
+    integral-type operator--() noexcept;
+    integral-type operator+=(integral-type) volatile noexcept;
+    integral-type operator+=(integral-type) noexcept;
+    integral-type operator-=(integral-type) volatile noexcept;
+    integral-type operator-=(integral-type) noexcept;
+    integral-type operator&=(integral-type) volatile noexcept;
+    integral-type operator&=(integral-type) noexcept;
+    integral-type operator|=(integral-type) volatile noexcept;
+    integral-type operator|=(integral-type) noexcept;
+    integral-type operator^=(integral-type) volatile noexcept;
+    integral-type operator^=(integral-type) noexcept;
+    void wait(integral-type, memory_order = memory_order::seq_cst) const volatile noexcept;
+    void wait(integral-type, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() volatile noexcept;
     void notify_one() noexcept;
     void notify_all() volatile noexcept;
     void notify_all() noexcept;
   };
 each have a trivial destructor.
 Descriptions are provided below only for members that differ from the
 primary template.
+The following operations perform arithmetic computations. The
+correspondence among key, operator, and computation is specified in
+[[atomic.types.int.comp]].
 **Table: Atomic arithmetic computations** <a id="atomic.types.int.comp">[atomic.types.int.comp]</a>
 |       |     |                      |       |     |                      |
 | ----- | --- | -------------------- | ----- | --- | -------------------- |
 `is_always_lock_free` is `true`.
 *Effects:* Equivalent to:
 `return fetch_`*`key`*`(operand) `*`op`*` operand;`
+#### Specializations for floating-point types <a id="atomics.types.float">[[atomics.types.float]]</a>
+There are specializations of the `atomic` class template for all
+cv-unqualified floating-point types. For each such type
+`floating-point-type`, the specialization `atomic<floating-point-type>`
 provides additional atomic operations appropriate to floating-point
 types.
 ``` cpp
 namespace std {
+  template<> struct atomic<floating-point-type> {
+    using value_type = floating-point-type;
     using difference_type = value_type;
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic type's operations are always lock free;
     bool is_lock_free() const volatile noexcept;
     bool is_lock_free() const noexcept;
     constexpr atomic() noexcept;
+    constexpr atomic(floating-point-type) noexcept;
     atomic(const atomic&) = delete;
     atomic& operator=(const atomic&) = delete;
     atomic& operator=(const atomic&) volatile = delete;
+    void store(floating-point-type, memory_order = memory_order::seq_cst) volatile noexcept;
+    void store(floating-point-type, memory_order = memory_order::seq_cst) noexcept;
+    floating-point-type operator=(floating-point-type) volatile noexcept;
+    floating-point-type operator=(floating-point-type) noexcept;
+    floating-point-type load(memory_order = memory_order::seq_cst) volatile noexcept;
+    floating-point-type load(memory_order = memory_order::seq_cst) noexcept;
+    operator floating-point-type() volatile noexcept;
+    operator floating-point-type() noexcept;
+    floating-point-type exchange(floating-point-type,
                                  memory_order = memory_order::seq_cst) volatile noexcept;
+    floating-point-type exchange(floating-point-type,
                                  memory_order = memory_order::seq_cst) noexcept;
+    bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                memory_order, memory_order) volatile noexcept;
+    bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                memory_order, memory_order) noexcept;
+    bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                  memory_order, memory_order) volatile noexcept;
+    bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                  memory_order, memory_order) noexcept;
+    bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                memory_order = memory_order::seq_cst) volatile noexcept;
+    bool compare_exchange_weak(floating-point-type&, floating-point-type,
                                memory_order = memory_order::seq_cst) noexcept;
+    bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                  memory_order = memory_order::seq_cst) volatile noexcept;
+    bool compare_exchange_strong(floating-point-type&, floating-point-type,
                                  memory_order = memory_order::seq_cst) noexcept;
+    floating-point-type fetch_add(floating-point-type,
                                   memory_order = memory_order::seq_cst) volatile noexcept;
+    floating-point-type fetch_add(floating-point-type,
                                   memory_order = memory_order::seq_cst) noexcept;
+    floating-point-type fetch_sub(floating-point-type,
                                   memory_order = memory_order::seq_cst) volatile noexcept;
+    floating-point-type fetch_sub(floating-point-type,
                                   memory_order = memory_order::seq_cst) noexcept;
+    floating-point-type operator+=(floating-point-type) volatile noexcept;
+    floating-point-type operator+=(floating-point-type) noexcept;
+    floating-point-type operator-=(floating-point-type) volatile noexcept;
+    floating-point-type operator-=(floating-point-type) noexcept;
+    void wait(floating-point-type, memory_order = memory_order::seq_cst) const volatile noexcept;
+    void wait(floating-point-type, memory_order = memory_order::seq_cst) const noexcept;
     void notify_one() volatile noexcept;
     void notify_one() noexcept;
     void notify_all() volatile noexcept;
     void notify_all() noexcept;
   };
 Descriptions are provided below only for members that differ from the
 primary template.
 The following operations perform arithmetic addition and subtraction
+computations. The correspondence among key, operator, and computation is
+specified in [[atomic.types.int.comp]].
 ``` cpp
 T fetch_key(T operand, memory_order order = memory_order::seq_cst) volatile noexcept;
 T fetch_key(T operand, memory_order order = memory_order::seq_cst) noexcept;
 ```
 the effects.
 *Remarks:* If the result is not a representable value for its
 type [[expr.pre]] the result is unspecified, but the operations
 otherwise have no undefined behavior. Atomic arithmetic operations on
+*`floating-point-type`* should conform to the
+`std::numeric_limits<`*`floating-point-type`*`>` traits associated with
+the floating-point type [[limits.syn]]. The floating-point
 environment [[cfenv]] for atomic arithmetic operations on
+*`floating-point-type`* may be different than the calling thread’s
 floating-point environment.
 ``` cpp
 T operator op=(T operand) volatile noexcept;
 T operator op=(T operand) noexcept;
 `return fetch_`*`key`*`(operand) `*`op`*` operand;`
 *Remarks:* If the result is not a representable value for its
 type [[expr.pre]] the result is unspecified, but the operations
 otherwise have no undefined behavior. Atomic arithmetic operations on
+*`floating-point-type`* should conform to the
+`std::numeric_limits<`*`floating-point-type`*`>` traits associated with
+the floating-point type [[limits.syn]]. The floating-point
 environment [[cfenv]] for atomic arithmetic operations on
+*`floating-point-type`* may be different than the calling thread’s
 floating-point environment.
+#### Partial specialization for pointers <a id="atomics.types.pointer">[[atomics.types.pointer]]</a>
 ``` cpp
 namespace std {
   template<class T> struct atomic<T*> {
     using value_type = T*;
 standard-layout structs. They each have a trivial destructor.
 Descriptions are provided below only for members that differ from the
 primary template.
+The following operations perform pointer arithmetic. The correspondence
+among key, operator, and computation is specified in
+[[atomic.types.pointer.comp]].
 **Table: Atomic pointer computations** <a id="atomic.types.pointer.comp">[atomic.types.pointer.comp]</a>
 |       |     |          |       |     |             |
 | ----- | --- | -------- | ----- | --- | ----------- |
 `is_always_lock_free` is `true`.
 *Effects:* Equivalent to:
 `return fetch_`*`key`*`(operand) `*`op`*` operand;`
+#### Member operators common to integers and pointers to objects <a id="atomics.types.memop">[[atomics.types.memop]]</a>
 ``` cpp
 value_type operator++(int) volatile noexcept;
 value_type operator++(int) noexcept;
 ```
 *Constraints:* For the `volatile` overload of this function,
 `is_always_lock_free` is `true`.
 *Effects:* Equivalent to: `return fetch_sub(1) - 1;`
+#### Partial specializations for smart pointers <a id="util.smartptr.atomic">[[util.smartptr.atomic]]</a>
+##### General <a id="util.smartptr.atomic.general">[[util.smartptr.atomic.general]]</a>
 The library provides partial specializations of the `atomic` template
+for shared-ownership smart pointers [[util.sharedptr]].
+[*Note 1*: The partial specializations are declared in header
+`<memory>`. — *end note*]
+The behavior of all operations is as specified in
+[[atomics.types.generic]], unless specified otherwise. The template
+parameter `T` of these partial specializations may be an incomplete
+type.
+All changes to an atomic smart pointer in [[util.smartptr.atomic]], and
+all associated `use_count` increments, are guaranteed to be performed
 atomically. Associated `use_count` decrements are sequenced after the
 atomic operation, but are not required to be part of it. Any associated
 deletion and deallocation are sequenced after the atomic update step and
 are not part of the atomic operation.
+[*Note 2*: If the atomic operation uses locks, locks acquired by the
 implementation will be held when any `use_count` adjustments are
 performed, and will not be held when any destruction or deallocation
 resulting from this is performed. — *end note*]
 [*Example 1*:
     shared_ptr<node> next;
   };
   atomic<shared_ptr<node>> head;
 public:
+ shared_ptr<node> find(T t) const {
     auto p = head.load();
     while (p && p->t != t)
       p = p->next;
+    return p;
   }
   void push_front(T t) {
     auto p = make_shared<node>();
     p->t = t;
 };
 ```
 — *end example*]
+##### Partial specialization for `shared_ptr` <a id="util.smartptr.atomic.shared">[[util.smartptr.atomic.shared]]</a>
 ``` cpp
 namespace std {
   template<class T> struct atomic<shared_ptr<T>> {
     using value_type = shared_ptr<T>;
     static constexpr bool is_always_lock_free = implementation-defined  // whether a given atomic type's operations are always lock free;
     bool is_lock_free() const noexcept;
     constexpr atomic() noexcept;
+    constexpr atomic(nullptr_t) noexcept : atomic() { }
     atomic(shared_ptr<T> desired) noexcept;
     atomic(const atomic&) = delete;
     void operator=(const atomic&) = delete;
     shared_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
 are eligible to be unblocked [[atomics.wait]] by this call.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]].
+##### Partial specialization for `weak_ptr` <a id="util.smartptr.atomic.weak">[[util.smartptr.atomic.weak]]</a>
 ``` cpp
 namespace std {
   template<class T> struct atomic<weak_ptr<T>> {
     using value_type = weak_ptr<T>;
 ```
 *Effects:* Initializes the object with the value `desired`.
 Initialization is not an atomic operation [[intro.multithread]].
+[*Note 2*: It is possible to have an access to an atomic object `A`
 race with its construction, for example, by communicating the address of
 the just-constructed object `A` to another thread via
 `memory_order::relaxed` operations on a suitable atomic pointer
 variable, and then immediately accessing `A` in the receiving thread.
 This results in undefined behavior. — *end note*]
 are eligible to be unblocked [[atomics.wait]] by this call.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]].
+### Non-member functions <a id="atomics.nonmembers">[[atomics.nonmembers]]</a>
 A non-member function template whose name matches the pattern `atomic_f`
 or the pattern `atomic_f_explicit` invokes the member function `f`, with
 the value of the first parameter as the object expression and the values
 of the remaining parameters (if any) as the arguments of the member
 [*Note 1*: The non-member functions enable programmers to write code
 that can be compiled as either C or C++, for example in a shared header
 file. — *end note*]
+### Flag type and operations <a id="atomics.flag">[[atomics.flag]]</a>
 ``` cpp
 namespace std {
   struct atomic_flag {
     constexpr atomic_flag() noexcept;
 ```
 The `atomic_flag` type provides the classic test-and-set functionality.
 It has two states, set and clear.
+Operations on an object of type `atomic_flag` shall be lock-free. The
+operations should also be address-free.
 The `atomic_flag` type is a standard-layout struct. It has a trivial
 destructor.
 ``` cpp
 are eligible to be unblocked [[atomics.wait]] by this call.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]].
+``` cpp
+#define ATOMIC_FLAG_INIT see below
+```
+*Remarks:* The macro `ATOMIC_FLAG_INIT` is defined in such a way that it
+can be used to initialize an object of type `atomic_flag` to the clear
+state. The macro can be used in the form:
+``` cpp
+atomic_flag guard = ATOMIC_FLAG_INIT;
+```
+It is unspecified whether the macro can be used in other initialization
+contexts. For a complete static-duration object, that initialization
+shall be static.
+### Fences <a id="atomics.fences">[[atomics.fences]]</a>
 This subclause introduces synchronization primitives called *fences*.
 Fences can have acquire semantics, release semantics, or both. A fence
 with acquire semantics is called an *acquire fence*. A fence with
 release semantics is called a *release fence*.
 handler. Compiler optimizations and reorderings of loads and stores are
 inhibited in the same way as with `atomic_thread_fence`, but the
 hardware fence instructions that `atomic_thread_fence` would have
 inserted are not emitted. — *end note*]
+### C compatibility <a id="stdatomic.h.syn">[[stdatomic.h.syn]]</a>
+The header `<stdatomic.h>` provides the following definitions:
+``` cpp
+template<class T>
+  using std-atomic = std::atomic<T>;        // exposition only
+#define _Atomic(T) std-atomic<T>
+#define ATOMIC_BOOL_LOCK_FREE see below
+#define ATOMIC_CHAR_LOCK_FREE see below
+#define ATOMIC_CHAR16_T_LOCK_FREE see below
+#define ATOMIC_CHAR32_T_LOCK_FREE see below
+#define ATOMIC_WCHAR_T_LOCK_FREE see below
+#define ATOMIC_SHORT_LOCK_FREE see below
+#define ATOMIC_INT_LOCK_FREE see below
+#define ATOMIC_LONG_LOCK_FREE see below
+#define ATOMIC_LLONG_LOCK_FREE see below
+#define ATOMIC_POINTER_LOCK_FREE see below
+using std::memory_order;             // see below
+using std::memory_order_relaxed;     // see below
+using std::memory_order_consume;     // see below
+using std::memory_order_acquire;     // see below
+using std::memory_order_release;     // see below
+using std::memory_order_acq_rel;     // see below
+using std::memory_order_seq_cst;     // see below
+using std::atomic_flag;              // see below
+using std::atomic_bool;              // see below
+using std::atomic_char;              // see below
+using std::atomic_schar;             // see below
+using std::atomic_uchar;             // see below
+using std::atomic_short;             // see below
+using std::atomic_ushort;            // see below
+using std::atomic_int;               // see below
+using std::atomic_uint;              // see below
+using std::atomic_long;              // see below
+using std::atomic_ulong;             // see below
+using std::atomic_llong;             // see below
+using std::atomic_ullong;            // see below
+using std::atomic_char8_t;           // see below
+using std::atomic_char16_t;          // see below
+using std::atomic_char32_t;          // see below
+using std::atomic_wchar_t;           // see below
+using std::atomic_int8_t;            // see below
+using std::atomic_uint8_t;           // see below
+using std::atomic_int16_t;           // see below
+using std::atomic_uint16_t;          // see below
+using std::atomic_int32_t;           // see below
+using std::atomic_uint32_t;          // see below
+using std::atomic_int64_t;           // see below
+using std::atomic_uint64_t;          // see below
+using std::atomic_int_least8_t;      // see below
+using std::atomic_uint_least8_t;     // see below
+using std::atomic_int_least16_t;     // see below
+using std::atomic_uint_least16_t;    // see below
+using std::atomic_int_least32_t;     // see below
+using std::atomic_uint_least32_t;    // see below
+using std::atomic_int_least64_t;     // see below
+using std::atomic_uint_least64_t;    // see below
+using std::atomic_int_fast8_t;       // see below
+using std::atomic_uint_fast8_t;      // see below
+using std::atomic_int_fast16_t;      // see below
+using std::atomic_uint_fast16_t;     // see below
+using std::atomic_int_fast32_t;      // see below
+using std::atomic_uint_fast32_t;     // see below
+using std::atomic_int_fast64_t;      // see below
+using std::atomic_uint_fast64_t;     // see below
+using std::atomic_intptr_t;          // see below
+using std::atomic_uintptr_t;         // see below
+using std::atomic_size_t;            // see below
+using std::atomic_ptrdiff_t;         // see below
+using std::atomic_intmax_t;          // see below
+using std::atomic_uintmax_t;         // see below
+using std::atomic_is_lock_free;                          // see below
+using std::atomic_load;                                  // see below
+using std::atomic_load_explicit;                         // see below
+using std::atomic_store;                                 // see below
+using std::atomic_store_explicit;                        // see below
+using std::atomic_exchange;                              // see below
+using std::atomic_exchange_explicit;                     // see below
+using std::atomic_compare_exchange_strong;               // see below
+using std::atomic_compare_exchange_strong_explicit;      // see below
+using std::atomic_compare_exchange_weak;                 // see below
+using std::atomic_compare_exchange_weak_explicit;        // see below
+using std::atomic_fetch_add;                             // see below
+using std::atomic_fetch_add_explicit;                    // see below
+using std::atomic_fetch_sub;                             // see below
+using std::atomic_fetch_sub_explicit;                    // see below
+using std::atomic_fetch_and;                             // see below
+using std::atomic_fetch_and_explicit;                    // see below
+using std::atomic_fetch_or;                              // see below
+using std::atomic_fetch_or_explicit;                     // see below
+using std::atomic_fetch_xor;                             // see below
+using std::atomic_fetch_xor_explicit;                    // see below
+using std::atomic_flag_test_and_set;                     // see below
+using std::atomic_flag_test_and_set_explicit;            // see below
+using std::atomic_flag_clear;                            // see below
+using std::atomic_flag_clear_explicit;                   // see below
+#define ATOMIC_FLAG_INIT see below
+using std::atomic_thread_fence;                          // see below
+using std::atomic_signal_fence;                          // see below
+```
+Each *using-declaration* for some name A in the synopsis above makes
+available the same entity as `std::A` declared in `<atomic>`. Each macro
+listed above other than `_Atomic(T)` is defined as in `<atomic>`. It is
+unspecified whether `<stdatomic.h>` makes available any declarations in
+namespace `std`.
+Each of the *using-declaration*s for `intN_t`, `uintN_t`, `intptr_t`,
+and `uintptr_t` listed above is defined if and only if the
+implementation defines the corresponding *typedef-name* in
+[[atomics.syn]].
+Neither the `_Atomic` macro, nor any of the non-macro global namespace
+declarations, are provided by any C++ standard library header other than
+`<stdatomic.h>`.
+*Recommended practice:* Implementations should ensure that C and C++
+representations of atomic objects are compatible, so that the same
+object can be accessed as both an `_Atomic(T)` from C code and an
+`atomic<T>` from C++ code. The representations should be the same, and
+the mechanisms used to ensure atomicity and memory ordering should be
+compatible.

Diff to HTML by rtfpessoa