Init

cppdraft/depr/atomics/general.md

@@ -0,0 +1,15 @@
+[depr.atomics.general]
+
+# Annex D (normative) Compatibility features [[depr]](./#depr)
+
+## D.23 Deprecated atomic operations [[depr.atomics]](depr.atomics#general)
+
+### D.23.1 General [depr.atomics.general]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/future.tex#L912)
+
+The header [<atomic>](atomics.syn#header:%3catomic%3e "32.5.2 Header <atomic> synopsis [atomics.syn]") has the following additions[.](#1.sentence-1)
+
+namespace std {template<class T>void atomic_init(volatile atomic<T>*, typename atomic<T>::value_type) noexcept; template<class T>void atomic_init(atomic<T>*, typename atomic<T>::value_type) noexcept; template<class T>constexpr T kill_dependency(T y) noexcept; // freestandinginline constexpr memory_order memory_order_consume = memory_order::consume; // freestanding#define ATOMIC_VAR_INIT(value) *see below*}

cppdraft/depr/atomics/nonmembers.md

@@ -0,0 +1,21 @@
+[depr.atomics.nonmembers]
+
+# Annex D (normative) Compatibility features [[depr]](./#depr)
+
+## D.23 Deprecated atomic operations [[depr.atomics]](depr.atomics#nonmembers)
+
+### D.23.3 Non-member functions [depr.atomics.nonmembers]
+
+[🔗](#lib:atomic_init)
+
+`template<class T>
+  void atomic_init(volatile atomic<T>* object, typename atomic<T>::value_type desired) noexcept;
+template<class T>
+  void atomic_init(atomic<T>* object, typename atomic<T>::value_type desired) noexcept;
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/future.tex#L964)
+
+*Effects*: Equivalent to: atomic_store_explicit(object, desired, memory_order​::​relaxed);

cppdraft/depr/atomics/order.md

@@ -0,0 +1,26 @@
+[depr.atomics.order]
+
+# Annex D (normative) Compatibility features [[depr]](./#depr)
+
+## D.23 Deprecated atomic operations [[depr.atomics]](depr.atomics#order)
+
+### D.23.5 memory_order​::​consume [depr.atomics.order]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/future.tex#L998)
+
+The memory_order enumeration contains an additional enumerator:consume = 1
+
+The memory_order​::​consume enumerator is allowed wherevermemory_order​::​acquire is allowed, and it has the same meaning[.](#1.sentence-2)
+
+[🔗](#itemdecl:1)
+
+`template<class T> constexpr T kill_dependency(T y) noexcept;
+`
+
+[2](#2)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/future.tex#L1011)
+
+*Returns*: y[.](#2.sentence-1)

cppdraft/depr/atomics/types/operations.md

@@ -0,0 +1,32 @@
+[depr.atomics.types.operations]
+
+# Annex D (normative) Compatibility features [[depr]](./#depr)
+
+## D.23 Deprecated atomic operations [[depr.atomics]](depr.atomics#types.operations)
+
+### D.23.4 Operations on atomic types [depr.atomics.types.operations]
+
+[🔗](#lib:ATOMIC_VAR_INIT)
+
+`#define ATOMIC_VAR_INIT(value) see below
+`
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/future.tex#L977)
+
+The macro expands to a token sequence suitable for constant initialization of
+an atomic variable with static storage duration of a type that
+is initialization-compatible with value[.](#1.sentence-1)
+
+[*Note [1](#note-1)*:
+
+This operation possibly needs to initialize locks[.](#1.sentence-2)
+
+— *end note*]
+
+Concurrent access to the variable being initialized,
+even via an atomic operation,
+constitutes a data race[.](#1.sentence-3)
+
+[*Example [1](#example-1)*: atomic<int> v = ATOMIC_VAR_INIT(5); — *end example*]

cppdraft/depr/atomics/volatile.md

@@ -0,0 +1,25 @@
+[depr.atomics.volatile]
+
+# Annex D (normative) Compatibility features [[depr]](./#depr)
+
+## D.23 Deprecated atomic operations [[depr.atomics]](depr.atomics#volatile)
+
+### D.23.2 Volatile access [depr.atomics.volatile]
+
+[1](#1)
+
+[#](http://github.com/Eelis/draft/tree/9adde4bc1c62ec234483e63ea3b70a59724c745a/source/future.tex#L930)
+
+If an atomic ([[atomics.types.generic]](atomics.types.generic "32.5.8 Class template atomic")) specialization has one of the following overloads,
+then that overload participates in overload resolution
+even if atomic<T>​::​is_always_lock_free is false:void store(T desired, memory_order order = memory_order::seq_cst) volatile noexcept;
+T operator=(T desired) volatile noexcept;
+T load(memory_order order = memory_order::seq_cst) const volatile noexcept;operator T() const volatile noexcept;
+T exchange(T desired, memory_order order = memory_order::seq_cst) volatile noexcept;bool compare_exchange_weak(T& expected, T desired,
+ memory_order success, memory_order failure) volatile noexcept;bool compare_exchange_strong(T& expected, T desired,
+ memory_order success, memory_order failure) volatile noexcept;bool compare_exchange_weak(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) volatile noexcept;
+T fetch_*key*(T operand, memory_order order = memory_order::seq_cst) volatile noexcept;
+T operator *op*=(T operand) volatile noexcept;
+T* fetch_*key*(ptrdiff_t operand, memory_order order = memory_order::seq_cst) volatile noexcept;