Go to the documentation of this file. 1 #ifndef BOOST_DETAIL_ATOMIC_GCC_PPC_HPP
2 #define BOOST_DETAIL_ATOMIC_GCC_PPC_HPP
54 #define BOOST_ATOMIC_CHAR_LOCK_FREE 2
55 #define BOOST_ATOMIC_CHAR16_T_LOCK_FREE 2
56 #define BOOST_ATOMIC_CHAR32_T_LOCK_FREE 2
57 #define BOOST_ATOMIC_WCHAR_T_LOCK_FREE 2
58 #define BOOST_ATOMIC_SHORT_LOCK_FREE 2
59 #define BOOST_ATOMIC_INT_LOCK_FREE 2
60 #define BOOST_ATOMIC_LONG_LOCK_FREE 2
61 #define BOOST_ATOMIC_ADDRESS_LOCK_FREE 2
62 #if defined(__powerpc64__)
63 #define BOOST_ATOMIC_LLONG_LOCK_FREE 2
65 #define BOOST_ATOMIC_LLONG_LOCK_FREE 0
67 #define BOOST_ATOMIC_BOOL_LOCK_FREE 2
77 #if !defined(__APPLE__)
79 #define BOOST_ATOMIC_ASM_SLOWPATH_CLEAR \
88 #define BOOST_ATOMIC_ASM_SLOWPATH_CLEAR \
105 #if defined(__powerpc64__)
106 __asm__ __volatile__ (
"lwsync" :::
"memory");
110 __asm__ __volatile__ (
"sync" :::
"memory");
122 __asm__ __volatile__ (
"isync");
124 __asm__ __volatile__ (
"" :::
"memory");
134 __asm__ __volatile__ (
"sync");
167 __asm__ __volatile__ (
189 :
"=&b" (original),
"+Z"(
v_)
215 :
"=&b" (expected),
"=&b" (success),
"+Z"(
v_)
216 :
"b" (expected),
"b" (desired)
245 :
"=&b" (expected),
"=&b" (success),
"+Z"(
v_)
246 :
"b" (expected),
"b" (desired)
268 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
287 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
305 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
323 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
341 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
387 __asm__ __volatile__ (
409 :
"=&b" (original),
"+Z"(
v_)
436 :
"=&b" (expected),
"=&b" (success),
"+Z"(
v_)
437 :
"b" (expected),
"b" (desired)
466 :
"=&b" (expected),
"=&b" (success),
"+Z"(
v_)
467 :
"b" (expected),
"b" (desired)
486 "rlwinm %1, %1, 0, 0xff\n"
489 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
505 "rlwinm %1, %1, 0, 0xff\n"
508 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
526 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
544 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
562 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
608 __asm__ __volatile__ (
630 :
"=&b" (original),
"+Z"(
v_)
657 :
"=&b" (expected),
"=&b" (success),
"+Z"(
v_)
658 :
"b" (expected),
"b" (desired)
687 :
"=&b" (expected),
"=&b" (success),
"+Z"(
v_)
688 :
"b" (expected),
"b" (desired)
710 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
729 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
747 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
765 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
783 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
829 __asm__ __volatile__ (
851 :
"=&b" (original),
"+Z"(
v_)
878 :
"=&b" (expected),
"=&b" (success),
"+Z"(
v_)
879 :
"b" (expected),
"b" (desired)
908 :
"=&b" (expected),
"=&b" (success),
"+Z"(
v_)
909 :
"b" (expected),
"b" (desired)
928 "rlwinm %1, %1, 0, 0xffff\n"
931 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
947 "rlwinm %1, %1, 0, 0xffff\n"
950 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
968 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
986 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
1004 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
1024 template<
typename T,
bool Sign>
1045 __asm__ __volatile__ (
1067 :
"=&b" (original),
"+Z"(
v_)
1094 :
"=&b" (expected),
"=&b" (success),
"+Z"(
v_)
1095 :
"b" (expected),
"b" (desired)
1124 :
"=&b" (expected),
"=&b" (success),
"+Z"(
v_)
1125 :
"b" (expected),
"b" (desired)
1146 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
1164 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
1182 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
1200 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
1218 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
1238 #if defined(__powerpc64__)
1240 template<
typename T,
bool Sign>
1241 class base_atomic<T, int, 8, Sign> {
1244 typedef T difference_type;
1261 __asm__ __volatile__ (
1283 :
"=&b" (original),
"+Z"(
v_)
1310 :
"=&b" (expected),
"=&b" (success),
"+Z"(
v_)
1311 :
"b" (expected),
"b" (desired)
1340 :
"=&b" (expected),
"=&b" (success),
"+Z"(
v_)
1341 :
"b" (expected),
"b" (desired)
1362 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
1380 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
1398 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
1416 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
1434 :
"=&b" (original),
"=&b" (tmp),
"+Z"(
v_)
1458 #if !defined(__powerpc64__)
1461 class base_atomic<void *,
void *, 4, Sign> {
1507 :
"=&b" (original),
"+Z"(v_)
1534 :
"=&b" (expected),
"=&b" (success),
"+Z"(v_)
1535 :
"b" (expected),
"b" (desired)
1564 :
"=&b" (expected),
"=&b" (success),
"+Z"(v_)
1565 :
"b" (expected),
"b" (desired)
1588 template<
typename T,
bool Sign>
1589 class base_atomic<T *,
void *, 4, Sign> {
1636 :
"=&b" (original),
"+Z"(v_)
1663 :
"=&b" (expected),
"=&b" (success),
"+Z"(v_)
1664 :
"b" (expected),
"b" (desired)
1693 :
"=&b" (expected),
"=&b" (success),
"+Z"(v_)
1694 :
"b" (expected),
"b" (desired)
1707 v = v *
sizeof(*v_);
1716 :
"=&b" (original),
"=&b" (tmp),
"+Z"(v_)
1726 v = v *
sizeof(*v_);
1735 :
"=&b" (original),
"=&b" (tmp),
"+Z"(v_)
1758 class base_atomic<void *,
void *, 8, Sign> {
1759 typedef base_atomic this_type;
1760 typedef void * value_type;
1762 explicit base_atomic(value_type v) : v_(v) {}
1763 base_atomic(
void) {}
1797 value_type original;
1804 :
"=&b" (original),
"+Z"(v_)
1813 compare_exchange_weak(
1814 value_type & expected,
1831 :
"=&b" (expected),
"=&b" (success),
"+Z"(v_)
1832 :
"b" (expected),
"b" (desired)
1843 compare_exchange_strong(
1844 value_type & expected,
1861 :
"=&b" (expected),
"=&b" (success),
"+Z"(v_)
1862 :
"b" (expected),
"b" (desired)
1873 is_lock_free(
void)
const volatile
1880 base_atomic(
const base_atomic &) ;
1881 void operator=(
const base_atomic &) ;
1885 template<
typename T,
bool Sign>
1886 class base_atomic<T *,
void *, 8, Sign> {
1887 typedef base_atomic this_type;
1888 typedef T * value_type;
1889 typedef ptrdiff_t difference_type;
1891 explicit base_atomic(value_type v) : v_(v) {}
1892 base_atomic(
void) {}
1926 value_type original;
1933 :
"=&b" (original),
"+Z"(v_)
1942 compare_exchange_weak(
1943 value_type & expected,
1960 :
"=&b" (expected),
"=&b" (success),
"+Z"(v_)
1961 :
"b" (expected),
"b" (desired)
1972 compare_exchange_strong(
1973 value_type & expected,
1990 :
"=&b" (expected),
"=&b" (success),
"+Z"(v_)
1991 :
"b" (expected),
"b" (desired)
2004 v = v *
sizeof(*v_);
2005 value_type original, tmp;
2013 :
"=&b" (original),
"=&b" (tmp),
"+Z"(v_)
2023 v = v *
sizeof(*v_);
2024 value_type original, tmp;
2032 :
"=&b" (original),
"=&b" (tmp),
"+Z"(v_)
2040 is_lock_free(
void)
const volatile
2047 base_atomic(
const base_atomic &) ;
2048 void operator=(
const base_atomic &) ;
2056 template<
typename T,
bool Sign>
2057 class base_atomic<T, void, 1, Sign> {
2086 __asm__ __volatile__ (
2113 :
"=&b" (original),
"+Z"(
v_)
2130 memcpy(&expected_s, &expected,
sizeof(
value_type));
2131 memcpy(&desired_s, &desired,
sizeof(
value_type));
2145 :
"=&b" (expected_s),
"=&b" (success),
"+Z"(
v_)
2146 :
"b" (expected_s),
"b" (desired_s)
2153 memcpy(&expected, &expected_s,
sizeof(
value_type));
2165 memcpy(&expected_s, &expected,
sizeof(
value_type));
2166 memcpy(&desired_s, &desired,
sizeof(
value_type));
2180 :
"=&b" (expected_s),
"=&b" (success),
"+Z"(
v_)
2181 :
"b" (expected_s),
"b" (desired_s)
2188 memcpy(&expected, &expected_s,
sizeof(
value_type));
2205 template<
typename T,
bool Sign>
2206 class base_atomic<T, void, 2, Sign> {
2235 __asm__ __volatile__ (
2262 :
"=&b" (original),
"+Z"(
v_)
2279 memcpy(&expected_s, &expected,
sizeof(
value_type));
2280 memcpy(&desired_s, &desired,
sizeof(
value_type));
2294 :
"=&b" (expected_s),
"=&b" (success),
"+Z"(
v_)
2295 :
"b" (expected_s),
"b" (desired_s)
2302 memcpy(&expected, &expected_s,
sizeof(
value_type));
2314 memcpy(&expected_s, &expected,
sizeof(
value_type));
2315 memcpy(&desired_s, &desired,
sizeof(
value_type));
2329 :
"=&b" (expected_s),
"=&b" (success),
"+Z"(
v_)
2330 :
"b" (expected_s),
"b" (desired_s)
2337 memcpy(&expected, &expected_s,
sizeof(
value_type));
2354 template<
typename T,
bool Sign>
2355 class base_atomic<T, void, 4, Sign> {
2384 __asm__ __volatile__ (
2411 :
"=&b" (original),
"+Z"(
v_)
2428 memcpy(&expected_s, &expected,
sizeof(
value_type));
2429 memcpy(&desired_s, &desired,
sizeof(
value_type));
2443 :
"=&b" (expected_s),
"=&b" (success),
"+Z"(
v_)
2444 :
"b" (expected_s),
"b" (desired_s)
2451 memcpy(&expected, &expected_s,
sizeof(
value_type));
2463 memcpy(&expected_s, &expected,
sizeof(
value_type));
2464 memcpy(&desired_s, &desired,
sizeof(
value_type));
2478 :
"=&b" (expected_s),
"=&b" (success),
"+Z"(
v_)
2479 :
"b" (expected_s),
"b" (desired_s)
2486 memcpy(&expected, &expected_s,
sizeof(
value_type));
2503 #if defined(__powerpc64__)
2505 template<
typename T,
bool Sign>
2506 class base_atomic<T, void, 8, Sign> {
2509 typedef uint64_t storage_type;
2535 __asm__ __volatile__ (
2554 storage_type tmp = 0, original;
2562 :
"=&b" (original),
"+Z"(
v_)
2578 storage_type expected_s, desired_s;
2579 memcpy(&expected_s, &expected,
sizeof(
value_type));
2580 memcpy(&desired_s, &desired,
sizeof(
value_type));
2594 :
"=&b" (expected_s),
"=&b" (success),
"+Z"(
v_)
2595 :
"b" (expected_s),
"b" (desired_s)
2602 memcpy(&expected, &expected_s,
sizeof(
value_type));
2613 storage_type expected_s, desired_s;
2614 memcpy(&expected_s, &expected,
sizeof(
value_type));
2615 memcpy(&desired_s, &desired,
sizeof(
value_type));
2629 :
"=&b" (expected_s),
"=&b" (success),
"+Z"(
v_)
2630 :
"b" (expected_s),
"b" (desired_s)
2637 memcpy(&expected, &expected_s,
sizeof(
value_type));
2658 #define BOOST_ATOMIC_THREAD_FENCE 2
2664 __asm__ __volatile__ (
"isync" :::
"memory");
2667 #if defined(__powerpc64__)
2668 __asm__ __volatile__ (
"lwsync" :::
"memory");
2673 __asm__ __volatile__ (
"sync" :::
"memory");
2678 #define BOOST_ATOMIC_SIGNAL_FENCE 2
2687 __asm__ __volatile__ (
"" :::
"memory");
static void ppc_fence_after_store(memory_order order)
value_type fetch_add(value_type v, memory_order order=memory_order_seq_cst) volatile
void store(value_type v, memory_order order=memory_order_seq_cst) volatile
value_type fetch_sub(value_type v, memory_order order=memory_order_seq_cst) volatile
base_atomic(value_type v)
bool compare_exchange_strong(value_type &expected, value_type desired, memory_order, memory_order) volatile
bool compare_exchange_strong(value_type &expected, value_type desired, memory_order success_order, memory_order failure_order) volatile
bool is_lock_free(void) const volatile
value_type fetch_or(value_type v, memory_order order=memory_order_seq_cst) volatile
static void atomic_signal_fence(memory_order)
bool is_lock_free(void) const volatile
bool compare_exchange_strong(value_type &expected, value_type desired, memory_order success_order, memory_order failure_order) volatile
void store(value_type v, memory_order order=memory_order_seq_cst) volatile
bool compare_exchange_weak(value_type &expected, value_type desired, memory_order success_order, memory_order failure_order) volatile
value_type exchange(value_type v, memory_order order=memory_order_seq_cst) volatile
value_type fetch_and(value_type v, memory_order order=memory_order_seq_cst) volatile
value_type fetch_sub(value_type v, memory_order order=memory_order_seq_cst) volatile
bool is_lock_free(void) const volatile
base_atomic(value_type v)
void store(value_type v, memory_order order=memory_order_seq_cst) volatile
value_type load(memory_order order=memory_order_seq_cst) const volatile
#define BOOST_ATOMIC_DECLARE_BASE_OPERATORS
bool compare_exchange_weak(value_type &expected, value_type desired, memory_order success_order, memory_order failure_order) volatile
value_type exchange(value_type v, memory_order order=memory_order_seq_cst) volatile
void store(value_type v, memory_order order=memory_order_seq_cst) volatile
value_type load(memory_order order=memory_order_seq_cst) const volatile
bool is_lock_free(void) const volatile
void store(value_type v, memory_order order=memory_order_seq_cst) volatile
value_type fetch_add(value_type v, memory_order order=memory_order_seq_cst) volatile
bool compare_exchange_strong(value_type &expected, value_type desired, memory_order success_order, memory_order failure_order) volatile
base_atomic(value_type v)
value_type fetch_or(value_type v, memory_order order=memory_order_seq_cst) volatile
bool compare_exchange_strong(value_type &expected, value_type desired, memory_order success_order, memory_order failure_order) volatile
value_type fetch_xor(value_type v, memory_order order=memory_order_seq_cst) volatile
value_type load(memory_order order=memory_order_seq_cst) const volatile
base_atomic(value_type v)
bool compare_exchange_weak(value_type &expected, value_type desired, memory_order success_order, memory_order failure_order) volatile
base_atomic(value_type v)
value_type fetch_add(difference_type v, memory_order order=memory_order_seq_cst) volatile
bool is_lock_free(void) const volatile
void operator=(const base_atomic &)
#define BOOST_ATOMIC_ASM_SLOWPATH_CLEAR
base_atomic(value_type v)
value_type fetch_xor(value_type v, memory_order order=memory_order_seq_cst) volatile
value_type load(memory_order order=memory_order_seq_cst) const volatile
void store(value_type v, memory_order order=memory_order_seq_cst) volatile
value_type fetch_and(value_type v, memory_order order=memory_order_seq_cst) volatile
bool is_lock_free(void) const volatile
value_type fetch_xor(value_type v, memory_order order=memory_order_seq_cst) volatile
void store(value_type v, memory_order=memory_order_seq_cst) volatile
value_type exchange(value_type v, memory_order order=memory_order_seq_cst) volatile
bool compare_exchange_strong(value_type &expected, value_type desired, memory_order success_order, memory_order failure_order) volatile
value_type load(memory_order order=memory_order_seq_cst) const volatile
bool compare_exchange_strong(value_type &expected, value_type desired, memory_order success_order, memory_order failure_order) volatile
value_type fetch_or(value_type v, memory_order order=memory_order_seq_cst) volatile
value_type exchange(value_type v, memory_order order=memory_order_seq_cst) volatile
bool compare_exchange_weak(value_type &expected, value_type desired, memory_order success_order, memory_order failure_order) volatile
void store(value_type v, memory_order order=memory_order_seq_cst) volatile
base_atomic(value_type v)
value_type load(memory_order order=memory_order_seq_cst) const volatile
value_type load(memory_order order=memory_order_seq_cst) const volatile
value_type load(memory_order order=memory_order_seq_cst) const volatile
value_type fetch_sub(value_type v, memory_order order=memory_order_seq_cst) volatile
#define BOOST_ATOMIC_DECLARE_INTEGRAL_OPERATORS
bool compare_exchange_weak(value_type &expected, value_type desired, memory_order success_order, memory_order failure_order) volatile
value_type exchange(value_type v, memory_order order=memory_order_seq_cst) volatile
bool compare_exchange_strong(value_type &expected, value_type desired, memory_order success_order, memory_order failure_order) volatile
value_type exchange(value_type v, memory_order order=memory_order_seq_cst) volatile
value_type exchange(value_type v, memory_order=memory_order_seq_cst) volatile
ptrdiff_t difference_type
value_type fetch_and(value_type v, memory_order order=memory_order_seq_cst) volatile
bool compare_exchange_weak(value_type &expected, value_type desired, memory_order success_order, memory_order failure_order) volatile
bool compare_exchange_strong(value_type &expected, value_type desired, memory_order success_order, memory_order failure_order) volatile
value_type fetch_or(value_type v, memory_order order=memory_order_seq_cst) volatile
bool compare_exchange_strong(value_type &expected, value_type desired, memory_order success_order, memory_order failure_order) volatile
static void ppc_fence_before(memory_order order)
bool compare_exchange_strong(value_type &expected, value_type desired, memory_order success_order, memory_order failure_order) volatile
static void ppc_fence_after(memory_order order)
value_type load(memory_order=memory_order_seq_cst) volatile const
value_type fetch_add(value_type v, memory_order order=memory_order_seq_cst) volatile
#define BOOST_ATOMIC_DECLARE_POINTER_OPERATORS
value_type exchange(value_type v, memory_order order=memory_order_seq_cst) volatile
bool compare_exchange_weak(value_type &expected, value_type desired, memory_order success_order, memory_order failure_order) volatile
bool compare_exchange_weak(value_type &expected, value_type desired, memory_order success_order, memory_order failure_order) volatile
value_type fetch_and(value_type v, memory_order order=memory_order_seq_cst) volatile
bool is_lock_free(void) const volatile
bool compare_exchange_weak(value_type &expected, value_type desired, memory_order success_order, memory_order failure_order) volatile
value_type exchange(value_type v, memory_order order=memory_order_seq_cst) volatile
value_type exchange(value_type v, memory_order order=memory_order_seq_cst) volatile
value_type fetch_sub(difference_type v, memory_order order=memory_order_seq_cst) volatile
value_type load(memory_order order=memory_order_seq_cst) const volatile
void store(value_type v, memory_order order=memory_order_seq_cst) volatile
bool compare_exchange_weak(value_type &expected, value_type desired, memory_order success_order, memory_order failure_order) volatile
value_type fetch_xor(value_type v, memory_order order=memory_order_seq_cst) volatile
value_type exchange(value_type v, memory_order order=memory_order_seq_cst) volatile
bool is_lock_free(void) const volatile
value_type fetch_add(value_type v, memory_order order=memory_order_seq_cst) volatile
bool is_lock_free(void) const volatile
value_type fetch_xor(value_type v, memory_order order=memory_order_seq_cst) volatile
value_type fetch_sub(value_type v, memory_order order=memory_order_seq_cst) volatile
value_type fetch_sub(value_type v, memory_order order=memory_order_seq_cst) volatile
base_atomic(value_type v)
value_type fetch_add(value_type v, memory_order order=memory_order_seq_cst) volatile
void store(value_type v, memory_order order=memory_order_seq_cst) volatile
static void atomic_thread_fence(memory_order order)
bool is_lock_free(void) const volatile
void store(value_type v, memory_order order=memory_order_seq_cst) volatile
value_type fetch_and(value_type v, memory_order order=memory_order_seq_cst) volatile
base_atomic(value_type v)
bool compare_exchange_weak(value_type &expected, value_type desired, memory_order success_order, memory_order failure_order) volatile
value_type load(memory_order order=memory_order_seq_cst) const volatile
base_atomic(value_type v)
value_type fetch_or(value_type v, memory_order order=memory_order_seq_cst) volatile
bool is_lock_free(void) const volatile
rosatomic
Author(s): Josh Faust
autogenerated on Wed Mar 2 2022 00:54:12