[atomics.ref.generic] - C++23 → Trunk

Files changed (1) hide show

tmp/tmps_rve45d/{from.md → to.md} +405 -142

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

@@ -7,38 +7,40 @@ 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;
     bool is_lock_free() const noexcept;
-    explicit atomic_ref(T&);
-    atomic_ref(const atomic_ref&) noexcept;
     atomic_ref& operator=(const atomic_ref&) = delete;
-    void store(T, memory_order = memory_order::seq_cst) const noexcept;
- T operator=(T) const noexcept;
- T load(memory_order = memory_order::seq_cst) const noexcept;
-    operator T() const noexcept;
- T exchange(T, memory_order = memory_order::seq_cst) const noexcept;
-    bool compare_exchange_weak(T&, T,
                                          memory_order, memory_order) const noexcept;
-    bool compare_exchange_strong(T&, T,
                                            memory_order, memory_order) const noexcept;
-    bool compare_exchange_weak(T&, T,
                                          memory_order = memory_order::seq_cst) const noexcept;
-    bool compare_exchange_strong(T&, T,
                                            memory_order = memory_order::seq_cst) const noexcept;
-    void wait(T, memory_order = memory_order::seq_cst) const noexcept;
-    void notify_one() const noexcept;
-    void notify_all() const noexcept;
   };
 }
 ```
 An `atomic_ref` object applies atomic operations [[atomics.general]] to
@@ -63,10 +65,13 @@ 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;
 ```
@@ -95,94 +100,103 @@ bool is_lock_free() const noexcept;
 *Returns:* `true` if operations on all objects of the type
 `atomic_ref<T>` are lock-free, `false` otherwise.
 ``` cpp
-atomic_ref(T& obj);
 ```
 *Preconditions:* The referenced object is aligned to
 `required_alignment`.
 *Ensures:* `*this` references `obj`.
 *Throws:* Nothing.
 ``` cpp
-atomic_ref(const atomic_ref& ref) noexcept;
 ```
 *Ensures:* `*this` references the object referenced by `ref`.
 ``` cpp
-void store(T desired, memory_order order = memory_order::seq_cst) const noexcept;
 ```
-*Preconditions:* The `order` argument is neither
-`memory_order::consume`, `memory_order::acquire`, nor
-`memory_order::acq_rel`.
 *Effects:* Atomically replaces the value referenced by `*ptr` with the
 value of `desired`. Memory is affected according to the value of
 `order`.
 ``` cpp
-T operator=(T desired) const noexcept;
 ```
 *Effects:* Equivalent to:
 ``` cpp
 store(desired);
 return desired;
 ```
 ``` cpp
-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`.
 *Effects:* Memory is affected according to the value of `order`.
 *Returns:* Atomically returns the value referenced by `*ptr`.
 ``` cpp
-operator T() const noexcept;
 ```
 *Effects:* Equivalent to: `return load();`
 ``` cpp
-T exchange(T desired, memory_order order = memory_order::seq_cst) const noexcept;
 ```
 *Effects:* Atomically replaces the value referenced by `*ptr` with
 `desired`. Memory is affected according to the value of `order`. This
 operation is an atomic read-modify-write
 operation [[intro.multithread]].
 *Returns:* Atomically returns the value referenced by `*ptr` immediately
 before the effects.
 ``` cpp
-bool compare_exchange_weak(T& expected, T desired,
                            memory_order success, memory_order failure) const noexcept;
-bool compare_exchange_strong(T& expected, T desired,
                              memory_order success, memory_order failure) const noexcept;
-bool compare_exchange_weak(T& expected, T desired,
                            memory_order order = memory_order::seq_cst) const noexcept;
-bool compare_exchange_strong(T& expected, T desired,
                              memory_order order = memory_order::seq_cst) const noexcept;
 ```
-*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 referenced by `*ptr` for
 equality with that previously retrieved from `expected`, and if `true`,
 replaces the value referenced by `*ptr` with that in `desired`. If and
@@ -216,15 +230,15 @@ 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*]
 ``` cpp
-void wait(T old, memory_order order = memory_order::seq_cst) const noexcept;
 ```
-*Preconditions:* `order` is neither `memory_order::release` nor
-`memory_order::acq_rel`.
 *Effects:* Repeatedly performs the following steps, in order:
 - Evaluates `load(order)` and compares its value representation for
   equality against that of `old`.
@@ -234,102 +248,131 @@ void wait(T old, memory_order order = memory_order::seq_cst) const noexcept;
 *Remarks:* This function is an atomic waiting operation [[atomics.wait]]
 on atomic object `*ptr`.
 ``` cpp
-void notify_one() const noexcept;
 ```
 *Effects:* Unblocks the execution of at least one atomic waiting
 operation on `*ptr` that is eligible to be unblocked [[atomics.wait]] by
 this call, if any such atomic waiting operations exist.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]] on atomic object `*ptr`.
 ``` cpp
-void notify_all() const noexcept;
 ```
 *Effects:* Unblocks the execution of all atomic waiting operations on
 `*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
@@ -338,107 +381,177 @@ 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`.
 These operations are atomic read-modify-write
 operations [[intro.races]].
 *Returns:* Atomically, the value referenced by `*ptr` immediately before
 the effects.
-*Remarks:* For signed integer types, the result is as if the object
-value and parameters were converted to their corresponding unsigned
-types, the computation performed on those types, and the result
-converted back to the signed type.
 [*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 given operand. Memory is affected according to the value of `order`.
 These operations are atomic read-modify-write
 operations [[intro.races]].
@@ -448,71 +561,167 @@ 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;
     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(T*&);
-    atomic_ref(const atomic_ref&) noexcept;
     atomic_ref& operator=(const atomic_ref&) = delete;
-    void store(T*, memory_order = memory_order::seq_cst) const noexcept;
- T* operator=(T*) const noexcept;
- T* load(memory_order = memory_order::seq_cst) const noexcept;
-    operator T*() const noexcept;
- T* exchange(T*, memory_order = memory_order::seq_cst) const noexcept;
-    bool compare_exchange_weak(T*&, T*,
                                          memory_order, memory_order) const noexcept;
-    bool compare_exchange_strong(T*&, T*,
                                            memory_order, memory_order) const noexcept;
-    bool compare_exchange_weak(T*&, T*,
                                    memory_order = memory_order::seq_cst) const noexcept;
- bool compare_exchange_strong(T*&, T*,
                                    memory_order = memory_order::seq_cst) const noexcept;
- T* fetch_add(difference_type, memory_order = memory_order::seq_cst) const noexcept;
-    T* fetch_sub(difference_type, memory_order = memory_order::seq_cst) const noexcept;
- T* operator++(int) const noexcept;
- T* operator--(int) const noexcept;
- T* operator++() const noexcept;
- T* operator--() const noexcept;
- T* operator+=(difference_type) const noexcept;
- T* operator-=(difference_type) const noexcept;
-    void wait(T*, 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
@@ -521,14 +730,18 @@ 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;
 ```
-*Mandates:* `T` is a complete object type.
 *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`.
 These operations are atomic read-modify-write
@@ -538,38 +751,88 @@ operations [[intro.races]].
 the effects.
 *Remarks:* The result may be an undefined address, but the operations
 otherwise have no undefined behavior.
 ``` cpp
-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;
 ```
 *Effects:* Equivalent to: `return fetch_add(1);`
 ``` cpp
-value_type operator--(int) const noexcept;
 ```
 *Effects:* Equivalent to: `return fetch_sub(1);`
 ``` cpp
-value_type operator++() const noexcept;
 ```
 *Effects:* Equivalent to: `return fetch_add(1) + 1;`
 ``` cpp
-value_type operator--() const noexcept;
 ```
 *Effects:* Equivalent to: `return fetch_sub(1) - 1;`

   template<class T> struct atomic_ref {
   private:
     T* ptr;             // exposition only
   public:
+    using value_type = remove_cv_t<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;
     bool is_lock_free() const noexcept;
+ constexpr explicit atomic_ref(T&);
+ constexpr atomic_ref(const atomic_ref&) noexcept;
     atomic_ref& operator=(const atomic_ref&) = delete;
+ constexpr void store(value_type, memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type operator=(value_type) const noexcept;
+ constexpr value_type load(memory_order = memory_order::seq_cst) const noexcept;
+ constexpr operator value_type() const noexcept;
+ constexpr value_type exchange(value_type,
+                                  memory_order = memory_order::seq_cst) const noexcept;
+    constexpr bool compare_exchange_weak(value_type&, value_type,
                                          memory_order, memory_order) const noexcept;
+ constexpr bool compare_exchange_strong(value_type&, value_type,
                                            memory_order, memory_order) const noexcept;
+ constexpr bool compare_exchange_weak(value_type&, value_type,
                                          memory_order = memory_order::seq_cst) const noexcept;
+ constexpr bool compare_exchange_strong(value_type&, value_type,
                                            memory_order = memory_order::seq_cst) const noexcept;
+ constexpr void wait(value_type, memory_order = memory_order::seq_cst) const noexcept;
+ constexpr void notify_one() const noexcept;
+ constexpr void notify_all() const noexcept;
+    constexpr T* address() const noexcept;
   };
 }
 ```
 An `atomic_ref` object applies atomic operations [[atomics.general]] to
 [*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*]
+The program is ill-formed if `is_always_lock_free` is `false` and
+`is_volatile_v<T>` is `true`.
 #### Operations <a id="atomics.ref.ops">[[atomics.ref.ops]]</a>
 ``` cpp
 static constexpr size_t required_alignment;
 ```
 *Returns:* `true` if operations on all objects of the type
 `atomic_ref<T>` are lock-free, `false` otherwise.
 ``` cpp
+constexpr atomic_ref(T& obj);
 ```
 *Preconditions:* The referenced object is aligned to
 `required_alignment`.
 *Ensures:* `*this` references `obj`.
 *Throws:* Nothing.
 ``` cpp
+constexpr atomic_ref(const atomic_ref& ref) noexcept;
 ```
 *Ensures:* `*this` references the object referenced by `ref`.
 ``` cpp
+constexpr void store(value_type desired,
+                     memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Constraints:* `is_const_v<T>` is `false`.
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::release`, or `memory_order::seq_cst`.
 *Effects:* Atomically replaces the value referenced by `*ptr` with the
 value of `desired`. Memory is affected according to the value of
 `order`.
 ``` cpp
+constexpr value_type operator=(value_type desired) const noexcept;
 ```
+*Constraints:* `is_const_v<T>` is `false`.
 *Effects:* Equivalent to:
 ``` cpp
 store(desired);
 return desired;
 ```
 ``` cpp
+constexpr value_type load(memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* Memory is affected according to the value of `order`.
 *Returns:* Atomically returns the value referenced by `*ptr`.
 ``` cpp
+constexpr operator value_type() const noexcept;
 ```
 *Effects:* Equivalent to: `return load();`
 ``` cpp
+constexpr value_type exchange(value_type desired,
+                              memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Constraints:* `is_const_v<T>` is `false`.
 *Effects:* Atomically replaces the value referenced by `*ptr` with
 `desired`. Memory is affected according to the value of `order`. This
 operation is an atomic read-modify-write
 operation [[intro.multithread]].
 *Returns:* Atomically returns the value referenced by `*ptr` immediately
 before the effects.
 ``` cpp
+constexpr bool compare_exchange_weak(value_type& expected, value_type desired,
                            memory_order success, memory_order failure) const noexcept;
+constexpr bool compare_exchange_strong(value_type& expected, value_type desired,
                              memory_order success, memory_order failure) const noexcept;
+constexpr bool compare_exchange_weak(value_type& expected, value_type desired,
                            memory_order order = memory_order::seq_cst) const noexcept;
+constexpr bool compare_exchange_strong(value_type& expected, value_type desired,
                              memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Constraints:* `is_const_v<T>` is `false`.
+*Preconditions:* `failure` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* Retrieves the value in `expected`. It then atomically
 compares the value representation of the value referenced by `*ptr` for
 equality with that previously retrieved from `expected`, and if `true`,
 replaces the value referenced by `*ptr` with that in `desired`. If and
 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*]
 ``` cpp
+constexpr void wait(value_type old, memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::acquire`, or `memory_order::seq_cst`.
 *Effects:* Repeatedly performs the following steps, in order:
 - Evaluates `load(order)` and compares its value representation for
   equality against that of `old`.
 *Remarks:* This function is an atomic waiting operation [[atomics.wait]]
 on atomic object `*ptr`.
 ``` cpp
+constexpr void notify_one() const noexcept;
 ```
+*Constraints:* `is_const_v<T>` is `false`.
 *Effects:* Unblocks the execution of at least one atomic waiting
 operation on `*ptr` that is eligible to be unblocked [[atomics.wait]] by
 this call, if any such atomic waiting operations exist.
 *Remarks:* This function is an atomic notifying
 operation [[atomics.wait]] on atomic object `*ptr`.
 ``` cpp
+constexpr void notify_all() const noexcept;
 ```
+*Constraints:* `is_const_v<T>` is `false`.
 *Effects:* Unblocks the execution of all atomic waiting operations on
 `*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`.
+``` cpp
+constexpr T* address() const noexcept;
+```
+*Returns:* `ptr`.
 #### Specializations for integral types <a id="atomics.ref.int">[[atomics.ref.int]]</a>
+There are specializations of the `atomic_ref` class template for all
+integral types except cv `bool`. 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*]
+The program is ill-formed if `is_always_lock_free` is `false` and
+`is_volatile_v<integral-type>` is `true`.
 ``` cpp
 namespace std {
   template<> struct atomic_ref<integral-type> {
   private:
     integral-type* ptr;         // exposition only
   public:
+    using value_type = remove_cv_t<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;
+ constexpr explicit atomic_ref(integral-type&);
+ constexpr atomic_ref(const atomic_ref&) noexcept;
     atomic_ref& operator=(const atomic_ref&) = delete;
+ constexpr void store(value_type, memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type operator=(value_type) const noexcept;
+ constexpr value_type load(memory_order = memory_order::seq_cst) const noexcept;
+ constexpr operator value_type() const noexcept;
+ constexpr value_type exchange(value_type,
                                   memory_order = memory_order::seq_cst) const noexcept;
+ constexpr bool compare_exchange_weak(value_type&, value_type,
                                          memory_order, memory_order) const noexcept;
+ constexpr bool compare_exchange_strong(value_type&, value_type,
                                            memory_order, memory_order) const noexcept;
+ constexpr bool compare_exchange_weak(value_type&, value_type,
                                          memory_order = memory_order::seq_cst) const noexcept;
+ constexpr bool compare_exchange_strong(value_type&, value_type,
                                            memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type fetch_add(value_type,
                                    memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type fetch_sub(value_type,
                                    memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type fetch_and(value_type,
                                    memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type fetch_or(value_type,
                                   memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type fetch_xor(value_type,
+                                   memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_max(value_type,
+                                   memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_min(value_type,
+                                   memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_add(value_type,
+                             memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_sub(value_type,
+                             memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_and(value_type,
+                             memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_or(value_type,
+                            memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_xor(value_type,
+                             memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_max(value_type,
+                             memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_min(value_type,
                              memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type operator++(int) const noexcept;
+ constexpr value_type operator--(int) const noexcept;
+ constexpr value_type operator++() const noexcept;
+ constexpr value_type operator--() const noexcept;
+ constexpr value_type operator+=(value_type) const noexcept;
+ constexpr value_type operator-=(value_type) const noexcept;
+ constexpr value_type operator&=(value_type) const noexcept;
+ constexpr value_type operator|=(value_type) const noexcept;
+ constexpr value_type operator^=(value_type) const noexcept;
+ constexpr void wait(value_type, memory_order = memory_order::seq_cst) const noexcept;
+ constexpr void notify_one() const noexcept;
+ constexpr void notify_all() const noexcept;
+    constexpr integral-type* address() const noexcept;
   };
 }
 ```
 Descriptions are provided below only for members that differ from the
 The following operations perform arithmetic computations. The
 correspondence among key, operator, and computation is specified in
 [[atomic.types.int.comp]].
 ``` cpp
+constexpr value_type fetch_key(value_type operand,
   memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Constraints:* `is_const_v<`*`integral-type`*`>` is `false`.
 *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`.
 These operations are atomic read-modify-write
 operations [[intro.races]].
 *Returns:* Atomically, the value referenced by `*ptr` immediately before
 the effects.
+*Remarks:* Except for `fetch_max` and `fetch_min`, for signed integer
+types the result is as if the object value and parameters were converted
+to their corresponding unsigned types, the computation performed on
+those types, and the result converted back to the signed type.
 [*Note 1*: There are no undefined results arising from the
 computation. — *end note*]
+For `fetch_max` and `fetch_min`, the maximum and minimum computation is
+performed as if by `max` and `min` algorithms [[alg.min.max]],
+respectively, with the object value and the first parameter as the
+arguments.
 ``` cpp
+constexpr void store_key(value_type operand,
+                         memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::release`, or `memory_order::seq_cst`.
+*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`. These operations are atomic modify-write
+operations [[atomics.order]].
+*Remarks:* Except for `store_max` and `store_min`, for signed integer
+types, the result is as if `*ptr` and parameters were converted to their
+corresponding unsigned types, the computation performed on those types,
+and the result converted back to the signed type.
+[*Note 2*: There are no undefined results arising from the
+computation. — *end note*]
+For `store_max` and `store_min`, the maximum and minimum computation is
+performed as if by `max` and `min` algorithms [[alg.min.max]],
+respectively, with `*ptr` and the first parameter as the arguments.
+``` cpp
+constexpr value_type operator op=(value_type operand) const noexcept;
+```
+*Constraints:* `is_const_v<`*`integral-type`*`>` is `false`.
 *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
+floating-point types. For each such type `floating-point-type`, the
+specialization `atomic_ref<floating-point-type>` provides additional
+atomic operations appropriate to floating-point types.
+The program is ill-formed if `is_always_lock_free` is `false` and
+`is_volatile_v<floating-point-type>` is `true`.
 ``` cpp
 namespace std {
   template<> struct atomic_ref<floating-point-type> {
   private:
     floating-point-type* ptr;   // exposition only
   public:
+    using value_type = remove_cv_t<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;
+ constexpr explicit atomic_ref(floating-point-type&);
+ constexpr atomic_ref(const atomic_ref&) noexcept;
     atomic_ref& operator=(const atomic_ref&) = delete;
+ constexpr void store(value_type,
+                         memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type operator=(value_type) const noexcept;
+ constexpr value_type load(memory_order = memory_order::seq_cst) const noexcept;
+    constexpr operator value_type() const noexcept;
+ constexpr value_type exchange(value_type,
                                   memory_order = memory_order::seq_cst) const noexcept;
+ constexpr bool compare_exchange_weak(value_type&, value_type,
                                          memory_order, memory_order) const noexcept;
+ constexpr bool compare_exchange_strong(value_type&, value_type,
                                            memory_order, memory_order) const noexcept;
+ constexpr bool compare_exchange_weak(value_type&, value_type,
+                                         memory_order = memory_order::seq_cst) const noexcept;
+    constexpr bool compare_exchange_strong(value_type&, value_type,
+                                           memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_add(value_type,
+                                   memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_sub(value_type,
+                                   memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_max(value_type,
                                    memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type fetch_min(value_type,
+                                   memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_fmaximum(value_type,
+                                        memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_fminimum(value_type,
+                                        memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_fmaximum_num(value_type,
+                                            memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_fminimum_num(value_type,
                                             memory_order = memory_order::seq_cst) const noexcept;
+ constexpr void store_add(value_type, memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_sub(value_type, memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_max(value_type, memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_min(value_type, memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_fmaximum(value_type,
                                   memory_order = memory_order::seq_cst) const noexcept;
+ constexpr void store_fminimum(value_type,
+                                  memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_fmaximum_num(value_type,
+                                      memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_fminimum_num(value_type,
                                       memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type operator+=(value_type) const noexcept;
+ constexpr value_type operator-=(value_type) const noexcept;
+ constexpr void wait(value_type,
+                        memory_order = memory_order::seq_cst) const noexcept;
+ constexpr void notify_one() const noexcept;
+    constexpr void notify_all() const noexcept;
+    constexpr floating-point-type* address() 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]], except for the keys `max`, `min`, `fmaximum`,
+`fminimum`, `fmaximum_num`, and `fminimum_num`, which are specified
+below.
 ``` cpp
+constexpr value_type fetch_key(value_type operand,
                           memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Constraints:* `is_const_v<`*`floating-point-type`*`>` is `false`.
 *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`.
 These operations are atomic read-modify-write
 operations [[intro.races]].
 *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<value_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.
+- For `fetch_fmaximum` and `fetch_fminimum`, the maximum and minimum
+  computation is performed as if by `fmaximum` and `fminimum`,
+  respectively, with `*ptr` and the first parameter as the arguments.
+- For `fetch_fmaximum_num` and `fetch_fminimum_num`, the maximum and
+  minimum computation is performed as if by `fmaximum_num` and
+  `fminimum_num`, respectively, with `*ptr` and the first parameter as
+  the arguments.
+- For `fetch_max` and `fetch_min`, the maximum and minimum computation
+  is performed as if by `fmaximum_num` and `fminimum_num`, respectively,
+  with `*ptr` and the first parameter as the arguments, except that:
+  - If both arguments are NaN, an unspecified NaN value is stored at
+    `*ptr`.
+  - If exactly one argument is a NaN, either the other argument or an
+    unspecified NaN value is stored at `*ptr`; it is unspecified which.
+  - If the arguments are differently signed zeros, which of these values
+    is stored at `*ptr` is unspecified.
+*Recommended practice:* The implementation of `fetch_max` and
+`fetch_min` should treat negative zero as smaller than positive zero.
 ``` cpp
+constexpr void store_key(value_type operand,
+                          memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::release`, or `memory_order::seq_cst`.
+*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`. These operations are atomic modify-write
+operations [[atomics.order]].
+*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
+`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. The arithmetic rules of floating-point
+atomic modify-write operations may be different from operations on
+floating-point types or atomic floating-point types.
+[*Note 1*: Tree reductions are permitted for atomic modify-write
+operations. — *end note*]
+- For `store_fmaximum` and `store_fminimum`, the maximum and minimum
+  computation is performed as if by `fmaximum` and `fminimum`,
+  respectively, with `*ptr` and the first parameter as the arguments.
+- For `store_fmaximum_num` and `store_fminimum_num`, the maximum and
+  minimum computation is performed as if by `fmaximum_num `and
+  `fminimum_num`, respectively, with `*ptr` and the first parameter as
+  the arguments.
+- For `store_max` and `store_min`, the maximum and minimum computation
+  is performed as if by `fmaximum_num` and `fminimum_num`, respectively,
+  with `*ptr` and the first parameter as the arguments, except that:
+  - If both arguments are NaN, an unspecified NaN value is stored at
+    `*ptr`.
+  - If exactly one argument is a NaN, either the other argument or an
+    unspecified NaN value is stored at `*ptr`, it is unspecified which.
+  - If the arguments are differently signed zeros, which of these values
+    is stored at `*ptr` is unspecified.
+*Recommended practice:* The implementation of `store_max` and
+`store_min` should treat negative zero as smaller than positive zero.
+``` cpp
+constexpr value_type operator op=(value_type operand) const noexcept;
+```
+*Constraints:* `is_const_v<`*`floating-point-type`*`>` is `false`.
 *Effects:* Equivalent to:
 `return fetch_`*`key`*`(operand) `*`op`*` operand;`
+#### Specialization for pointers <a id="atomics.ref.pointer">[[atomics.ref.pointer]]</a>
+There are specializations of the `atomic_ref` class template for all
+pointer-to-object types. For each such type `pointer-type`, the
+specialization `atomic_ref<pointer-type>` provides additional atomic
+operations appropriate to pointer types.
+The program is ill-formed if `is_always_lock_free` is `false` and
+`is_volatile_v<pointer-type>` is `true`.
 ``` cpp
 namespace std {
+  template<> struct atomic_ref<pointer-type> {
   private:
+ pointer-type* ptr;        // exposition only
   public:
+    using value_type = remove_cv_t<pointer-type>;
     using difference_type = ptrdiff_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;
     bool is_lock_free() const noexcept;
+ constexpr explicit atomic_ref(pointer-type&);
+ constexpr atomic_ref(const atomic_ref&) noexcept;
     atomic_ref& operator=(const atomic_ref&) = delete;
+ constexpr void store(value_type, memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type operator=(value_type) const noexcept;
+ constexpr value_type load(memory_order = memory_order::seq_cst) const noexcept;
+ constexpr operator value_type() const noexcept;
+ constexpr value_type exchange(value_type,
+                                  memory_order = memory_order::seq_cst) const noexcept;
+    constexpr bool compare_exchange_weak(value_type&, value_type,
                                          memory_order, memory_order) const noexcept;
+ constexpr bool compare_exchange_strong(value_type&, value_type,
                                            memory_order, memory_order) const noexcept;
+ constexpr bool compare_exchange_weak(value_type&, value_type,
+                                         memory_order = memory_order::seq_cst) const noexcept;
+    constexpr bool compare_exchange_strong(value_type&, value_type,
+                                           memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_add(difference_type,
+                                   memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_sub(difference_type,
                                    memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type fetch_max(value_type,
+                                   memory_order = memory_order::seq_cst) const noexcept;
+    constexpr value_type fetch_min(value_type,
                                    memory_order = memory_order::seq_cst) const noexcept;
+ constexpr void store_add(difference_type,
+ memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_sub(difference_type,
+                             memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_max(value_type,
+                             memory_order = memory_order::seq_cst) const noexcept;
+    constexpr void store_min(value_type,
+                             memory_order = memory_order::seq_cst) const noexcept;
+ constexpr value_type operator++(int) const noexcept;
+ constexpr value_type operator--(int) const noexcept;
+ constexpr value_type operator++() const noexcept;
+ constexpr value_type operator--() const noexcept;
+ constexpr value_type operator+=(difference_type) const noexcept;
+ constexpr value_type operator-=(difference_type) const noexcept;
+ constexpr void wait(value_type, memory_order = memory_order::seq_cst) const noexcept;
+ constexpr void notify_one() const noexcept;
+ constexpr void notify_all() const noexcept;
+    constexpr pointer-type* address() const noexcept;
   };
 }
 ```
 Descriptions are provided below only for members that differ from the
 The following operations perform arithmetic computations. The
 correspondence among key, operator, and computation is specified in
 [[atomic.types.pointer.comp]].
 ``` cpp
+constexpr value_type fetch_key(\seeabovenc operand,
+                               memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Constraints:* `is_const_v<`*`pointer-type`*`>` is `false`.
+*Mandates:* `remove_pointer_t<`*`pointer-type`*`>` is a complete object
+type.
 *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`.
 These operations are atomic read-modify-write
 the effects.
 *Remarks:* The result may be an undefined address, but the operations
 otherwise have no undefined behavior.
+For `fetch_max` and `fetch_min`, the maximum and minimum computation is
+performed as if by `max` and `min` algorithms [[alg.min.max]],
+respectively, with the object value and the first parameter as the
+arguments.
+[*Note 1*: If the pointers point to different complete objects (or
+subobjects thereof), the `<` operator does not establish a strict weak
+ordering ([[cpp17.lessthancomparable]], [[expr.rel]]). — *end note*]
 ``` cpp
+constexpr void store_key(\seeabovenc operand,
+                         memory_order order = memory_order::seq_cst) const noexcept;
 ```
+*Mandates:* `remove_pointer_t<`*`pointer-type`*`>` is a complete object
+type.
+*Preconditions:* `order` is `memory_order::relaxed`,
+`memory_order::release`, or `memory_order::seq_cst`.
+*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`. These operations are atomic modify-write
+operations [[atomics.order]].
+*Remarks:* The result may be an undefined address, but the operations
+otherwise have no undefined behavior. For `store_max` and `store_min`,
+the `maximum` and `minimum` computation is performed as if by `max` and
+`min` algorithms [[alg.min.max]], respectively, with `*ptr` and the
+first parameter as the arguments.
+[*Note 2*: If the pointers point to different complete objects (or
+subobjects thereof), the `<` operator does not establish a strict weak
+ordering ([[cpp17.lessthancomparable]], [[expr.rel]]). — *end note*]
+``` cpp
+constexpr value_type operator op=(difference_type operand) const noexcept;
+```
+*Constraints:* `is_const_v<`*`pointer-type`*`>` is `false`.
 *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>
+Let `referred-type` be `pointer-type` for the specializations in
+[[atomics.ref.pointer]] and be `integral-type` for the specializations
+in [[atomics.ref.int]].
 ``` cpp
+constexpr value_type operator++(int) const noexcept;
 ```
+*Constraints:* `is_const_v<`*`referred-type`*`>` is `false`.
 *Effects:* Equivalent to: `return fetch_add(1);`
 ``` cpp
+constexpr value_type operator--(int) const noexcept;
 ```
+*Constraints:* `is_const_v<`*`referred-type`*`>` is `false`.
 *Effects:* Equivalent to: `return fetch_sub(1);`
 ``` cpp
+constexpr value_type operator++() const noexcept;
 ```
+*Constraints:* `is_const_v<`*`referred-type`*`>` is `false`.
 *Effects:* Equivalent to: `return fetch_add(1) + 1;`
 ``` cpp
+constexpr value_type operator--() const noexcept;
 ```
+*Constraints:* `is_const_v<`*`referred-type`*`>` is `false`.
 *Effects:* Equivalent to: `return fetch_sub(1) - 1;`

Diff to HTML by rtfpessoa