Lines Matching +full:- +full:t
1 // -*- C++ -*-
2 //===----------------------------------------------------------------------===//
6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
8 //===----------------------------------------------------------------------===//
31 consume, // load-consume
32 acquire, // load-acquire
33 release, // store-release
34 acq_rel, // store-release load-acquire
35 seq_cst // store-release load-acquire
45 template <class T> T kill_dependency(T y) noexcept;
47 // lock-free property
61 template <class T>
64 using value_type = T;
71 constexpr atomic() noexcept(is_nothrow_default_constructible_v<T>); // since C++20
72 constexpr atomic(T desr) noexcept;
77 T load(memory_order m = memory_order_seq_cst) const volatile noexcept;
78 T load(memory_order m = memory_order_seq_cst) const noexcept;
79 operator T() const volatile noexcept;
80 operator T() const noexcept;
81 void store(T desr, memory_order m = memory_order_seq_cst) volatile noexcept;
82 void store(T desr, memory_order m = memory_order_seq_cst) noexcept;
83 T operator=(T) volatile noexcept;
84 T operator=(T) noexcept;
86 T exchange(T desr, memory_order m = memory_order_seq_cst) volatile noexcept;
87 T exchange(T desr, memory_order m = memory_order_seq_cst) noexcept;
88 bool compare_exchange_weak(T& expc, T desr,
90 bool compare_exchange_weak(T& expc, T desr, memory_order s, memory_order f) noexcept;
91 bool compare_exchange_strong(T& expc, T desr,
93 bool compare_exchange_strong(T& expc, T desr,
95 bool compare_exchange_weak(T& expc, T desr,
97 bool compare_exchange_weak(T& expc, T desr,
99 bool compare_exchange_strong(T& expc, T desr,
101 bool compare_exchange_strong(T& expc, T desr,
104 void wait(T, memory_order = memory_order::seq_cst) const volatile noexcept;
105 void wait(T, memory_order = memory_order::seq_cst) const noexcept;
170 integral operator--(int) volatile noexcept;
171 integral operator--(int) noexcept;
174 integral operator--() volatile noexcept;
175 integral operator--() noexcept;
178 integral operator-=(integral op) volatile noexcept;
179 integral operator-=(integral op) noexcept;
195 template <class T>
196 struct atomic<T*>
198 using value_type = T*;
207 constexpr atomic(T* desr) noexcept;
212 T* load(memory_order m = memory_order_seq_cst) const volatile noexcept;
213 T* load(memory_order m = memory_order_seq_cst) const noexcept;
214 operator T*() const volatile noexcept;
215 operator T*() const noexcept;
216 void store(T* desr, memory_order m = memory_order_seq_cst) volatile noexcept;
217 void store(T* desr, memory_order m = memory_order_seq_cst) noexcept;
218 T* operator=(T*) volatile noexcept;
219 T* operator=(T*) noexcept;
221 T* exchange(T* desr, memory_order m = memory_order_seq_cst) volatile noexcept;
222 T* exchange(T* desr, memory_order m = memory_order_seq_cst) noexcept;
223 bool compare_exchange_weak(T*& expc, T* desr,
225 bool compare_exchange_weak(T*& expc, T* desr,
227 bool compare_exchange_strong(T*& expc, T* desr,
229 bool compare_exchange_strong(T*& expc, T* desr,
231 bool compare_exchange_weak(T*& expc, T* desr,
233 bool compare_exchange_weak(T*& expc, T* desr,
235 bool compare_exchange_strong(T*& expc, T* desr,
237 bool compare_exchange_strong(T*& expc, T* desr,
239 T* fetch_add(ptrdiff_t op, memory_order m = memory_order_seq_cst) volatile noexcept;
240 T* fetch_add(ptrdiff_t op, memory_order m = memory_order_seq_cst) noexcept;
241 T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst) volatile noexcept;
242 T* fetch_sub(ptrdiff_t op, memory_order m = memory_order_seq_cst) noexcept;
244 T* operator++(int) volatile noexcept;
245 T* operator++(int) noexcept;
246 T* operator--(int) volatile noexcept;
247 T* operator--(int) noexcept;
248 T* operator++() volatile noexcept;
249 T* operator++() noexcept;
250 T* operator--() volatile noexcept;
251 T* operator--() noexcept;
252 T* operator+=(ptrdiff_t op) volatile noexcept;
253 T* operator+=(ptrdiff_t op) noexcept;
254 T* operator-=(ptrdiff_t op) volatile noexcept;
255 T* operator-=(ptrdiff_t op) noexcept;
257 void wait(T*, memory_order = memory_order::seq_cst) const volatile noexcept;
258 void wait(T*, memory_order = memory_order::seq_cst) const noexcept;
266 struct atomic<floating-point-type> { // since C++20
267 using value_type = floating-point-type;
270 static constexpr bool is_always_lock_free = implementation-defined;
275 constexpr atomic(floating-point-type) noexcept;
280 void store(floating-point-type, memory_order = memory_order::seq_cst) volatile noexcept;
281 void store(floating-point-type, memory_order = memory_order::seq_cst) noexcept;
282 floating-point-type operator=(floating-point-type) volatile noexcept;
283 floating-point-type operator=(floating-point-type) noexcept;
284 floating-point-type load(memory_order = memory_order::seq_cst) volatile noexcept;
285 floating-point-type load(memory_order = memory_order::seq_cst) noexcept;
286 operator floating-point-type() volatile noexcept;
287 operator floating-point-type() noexcept;
289 floating-point-type exchange(floating-point-type,
291 floating-point-type exchange(floating-point-type,
293 bool compare_exchange_weak(floating-point-type&, floating-point-type,
295 bool compare_exchange_weak(floating-point-type&, floating-point-type,
297 bool compare_exchange_strong(floating-point-type&, floating-point-type,
299 bool compare_exchange_strong(floating-point-type&, floating-point-type,
301 bool compare_exchange_weak(floating-point-type&, floating-point-type,
303 bool compare_exchange_weak(floating-point-type&, floating-point-type,
305 bool compare_exchange_strong(floating-point-type&, floating-point-type,
307 bool compare_exchange_strong(floating-point-type&, floating-point-type,
310 floating-point-type fetch_add(floating-point-type,
312 floating-point-type fetch_add(floating-point-type,
314 floating-point-type fetch_sub(floating-point-type,
316 floating-point-type fetch_sub(floating-point-type,
319 floating-point-type operator+=(floating-point-type) volatile noexcept;
320 floating-point-type operator+=(floating-point-type) noexcept;
321 floating-point-type operator-=(floating-point-type) volatile noexcept;
322 floating-point-type operator-=(floating-point-type) noexcept;
324 void wait(floating-point-type, memory_order = memory_order::seq_cst) const volatile noexcept;
325 void wait(floating-point-type, memory_order = memory_order::seq_cst) const noexcept;
332 // [atomics.nonmembers], non-member functions
333 template<class T>
334 bool atomic_is_lock_free(const volatile atomic<T>*) noexcept;
335 template<class T>
336 bool atomic_is_lock_free(const atomic<T>*) noexcept;
337 template<class T>
338 void atomic_store(volatile atomic<T>*, atomic<T>::value_type) noexcept;
339 template<class T>
340 void atomic_store(atomic<T>*, atomic<T>::value_type) noexcept;
341 template<class T>
342 void atomic_store_explicit(volatile atomic<T>*, atomic<T>::value_type,
344 template<class T>
345 void atomic_store_explicit(atomic<T>*, atomic<T>::value_type,
347 template<class T>
348 T atomic_load(const volatile atomic<T>*) noexcept;
349 template<class T>
350 T atomic_load(const atomic<T>*) noexcept;
351 template<class T>
352 T atomic_load_explicit(const volatile atomic<T>*, memory_order) noexcept;
353 template<class T>
354 T atomic_load_explicit(const atomic<T>*, memory_order) noexcept;
355 template<class T>
356 T atomic_exchange(volatile atomic<T>*, atomic<T>::value_type) noexcept;
357 template<class T>
358 T atomic_exchange(atomic<T>*, atomic<T>::value_type) noexcept;
359 template<class T>
360 T atomic_exchange_explicit(volatile atomic<T>*, atomic<T>::value_type,
362 template<class T>
363 T atomic_exchange_explicit(atomic<T>*, atomic<T>::value_type,
365 template<class T>
366 bool atomic_compare_exchange_weak(volatile atomic<T>*, atomic<T>::value_type*,
367 atomic<T>::value_type) noexcept;
368 template<class T>
369 bool atomic_compare_exchange_weak(atomic<T>*, atomic<T>::value_type*,
370 atomic<T>::value_type) noexcept;
371 template<class T>
372 bool atomic_compare_exchange_strong(volatile atomic<T>*, atomic<T>::value_type*,
373 atomic<T>::value_type) noexcept;
374 template<class T>
375 bool atomic_compare_exchange_strong(atomic<T>*, atomic<T>::value_type*,
376 atomic<T>::value_type) noexcept;
377 template<class T>
378 bool atomic_compare_exchange_weak_explicit(volatile atomic<T>*, atomic<T>::value_type*,
379 atomic<T>::value_type,
381 template<class T>
382 bool atomic_compare_exchange_weak_explicit(atomic<T>*, atomic<T>::value_type*,
383 atomic<T>::value_type,
385 template<class T>
386 bool atomic_compare_exchange_strong_explicit(volatile atomic<T>*, atomic<T>::value_type*,
387 atomic<T>::value_type,
389 template<class T>
390 bool atomic_compare_exchange_strong_explicit(atomic<T>*, atomic<T>::value_type*,
391 atomic<T>::value_type,
394 template<class T>
395 T atomic_fetch_add(volatile atomic<T>*, atomic<T>::difference_type) noexcept;
396 template<class T>
397 T atomic_fetch_add(atomic<T>*, atomic<T>::difference_type) noexcept;
398 template<class T>
399 T atomic_fetch_add_explicit(volatile atomic<T>*, atomic<T>::difference_type,
401 template<class T>
402 T atomic_fetch_add_explicit(atomic<T>*, atomic<T>::difference_type,
404 template<class T>
405 T atomic_fetch_sub(volatile atomic<T>*, atomic<T>::difference_type) noexcept;
406 template<class T>
407 T atomic_fetch_sub(atomic<T>*, atomic<T>::difference_type) noexcept;
408 template<class T>
409 T atomic_fetch_sub_explicit(volatile atomic<T>*, atomic<T>::difference_type,
411 template<class T>
412 T atomic_fetch_sub_explicit(atomic<T>*, atomic<T>::difference_type,
414 template<class T>
415 T atomic_fetch_and(volatile atomic<T>*, atomic<T>::value_type) noexcept;
416 template<class T>
417 T atomic_fetch_and(atomic<T>*, atomic<T>::value_type) noexcept;
418 template<class T>
419 T atomic_fetch_and_explicit(volatile atomic<T>*, atomic<T>::value_type,
421 template<class T>
422 T atomic_fetch_and_explicit(atomic<T>*, atomic<T>::value_type,
424 template<class T>
425 T atomic_fetch_or(volatile atomic<T>*, atomic<T>::value_type) noexcept;
426 template<class T>
427 T atomic_fetch_or(atomic<T>*, atomic<T>::value_type) noexcept;
428 template<class T>
429 T atomic_fetch_or_explicit(volatile atomic<T>*, atomic<T>::value_type,
431 template<class T>
432 T atomic_fetch_or_explicit(atomic<T>*, atomic<T>::value_type,
434 template<class T>
435 T atomic_fetch_xor(volatile atomic<T>*, atomic<T>::value_type) noexcept;
436 template<class T>
437 T atomic_fetch_xor(atomic<T>*, atomic<T>::value_type) noexcept;
438 template<class T>
439 T atomic_fetch_xor_explicit(volatile atomic<T>*, atomic<T>::value_type,
441 template<class T>
442 T atomic_fetch_xor_explicit(atomic<T>*, atomic<T>::value_type,
445 template<class T>
446 void atomic_wait(const volatile atomic<T>*, atomic<T>::value_type) noexcept;
447 template<class T>
448 void atomic_wait(const atomic<T>*, atomic<T>::value_type) noexcept;
449 template<class T>
450 void atomic_wait_explicit(const volatile atomic<T>*, atomic<T>::value_type,
452 template<class T>
453 void atomic_wait_explicit(const atomic<T>*, atomic<T>::value_type,
455 template<class T>
456 void atomic_notify_one(volatile atomic<T>*) noexcept;
457 template<class T>
458 void atomic_notify_one(atomic<T>*) noexcept;
459 template<class T>
460 void atomic_notify_all(volatile atomic<T>*) noexcept;
461 template<class T>
462 void atomic_notify_all(atomic<T>*) noexcept;
517 typedef see-below atomic_signed_lock_free; // since C++20
518 typedef see-below atomic_unsigned_lock_free; // since C++20
560 void atomic_wait(const volatile atomic_flag* obj, T old) noexcept;
561 void atomic_wait(const atomic_flag* obj, T old) noexcept;
562 void atomic_wait_explicit(const volatile atomic_flag* obj, T old, memory_order m) noexcept;
563 void atomic_wait_explicit(const atomic_flag* obj, T old, memory_order m) noexcept;
576 template <class T>
577 void atomic_init(volatile atomic<T>* obj, atomic<T>::value_type desr) noexcept;
579 template <class T>
580 void atomic_init(atomic<T>* obj, atomic<T>::value_type desr) noexcept;
593 # error <atomic> is incompatible with <stdatomic.h> before C++23. Please compile with -std=c++23.