python3.13/cpython/pyatomic_gcc.h

0001 // This is the implementation of Python atomic operations using GCC's built-in
0002 // functions that match the C+11 memory model. This implementation is preferred
0003 // for GCC compatible compilers, such as Clang. These functions are available
0004 // in GCC 4.8+ without needing to compile with --std=c11 or --std=gnu11.
0005
0006 #ifndef Py_ATOMIC_GCC_H
0007 #  error "this header file must not be included directly"
0008 #endif
0009
0010
0011 // --- _Py_atomic_add --------------------------------------------------------
0012
0013 static inline int
0014 _Py_atomic_add_int(int *obj, int value)
0015 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
0016
0017 static inline int8_t
0018 _Py_atomic_add_int8(int8_t *obj, int8_t value)
0019 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
0020
0021 static inline int16_t
0022 _Py_atomic_add_int16(int16_t *obj, int16_t value)
0023 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
0024
0025 static inline int32_t
0026 _Py_atomic_add_int32(int32_t *obj, int32_t value)
0027 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
0028
0029 static inline int64_t
0030 _Py_atomic_add_int64(int64_t *obj, int64_t value)
0031 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
0032
0033 static inline intptr_t
0034 _Py_atomic_add_intptr(intptr_t *obj, intptr_t value)
0035 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
0036
0037 static inline unsigned int
0038 _Py_atomic_add_uint(unsigned int *obj, unsigned int value)
0039 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
0040
0041 static inline uint8_t
0042 _Py_atomic_add_uint8(uint8_t *obj, uint8_t value)
0043 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
0044
0045 static inline uint16_t
0046 _Py_atomic_add_uint16(uint16_t *obj, uint16_t value)
0047 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
0048
0049 static inline uint32_t
0050 _Py_atomic_add_uint32(uint32_t *obj, uint32_t value)
0051 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
0052
0053 static inline uint64_t
0054 _Py_atomic_add_uint64(uint64_t *obj, uint64_t value)
0055 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
0056
0057 static inline uintptr_t
0058 _Py_atomic_add_uintptr(uintptr_t *obj, uintptr_t value)
0059 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
0060
0061 static inline Py_ssize_t
0062 _Py_atomic_add_ssize(Py_ssize_t *obj, Py_ssize_t value)
0063 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
0064
0065
0066 // --- _Py_atomic_compare_exchange -------------------------------------------
0067
0068 static inline int
0069 _Py_atomic_compare_exchange_int(int *obj, int *expected, int desired)
0070 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
0071                                      __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
0072
0073 static inline int
0074 _Py_atomic_compare_exchange_int8(int8_t *obj, int8_t *expected, int8_t desired)
0075 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
0076                                      __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
0077
0078 static inline int
0079 _Py_atomic_compare_exchange_int16(int16_t *obj, int16_t *expected, int16_t desired)
0080 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
0081                                      __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
0082
0083 static inline int
0084 _Py_atomic_compare_exchange_int32(int32_t *obj, int32_t *expected, int32_t desired)
0085 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
0086                                      __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
0087
0088 static inline int
0089 _Py_atomic_compare_exchange_int64(int64_t *obj, int64_t *expected, int64_t desired)
0090 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
0091                                      __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
0092
0093 static inline int
0094 _Py_atomic_compare_exchange_intptr(intptr_t *obj, intptr_t *expected, intptr_t desired)
0095 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
0096                                      __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
0097
0098 static inline int
0099 _Py_atomic_compare_exchange_uint(unsigned int *obj, unsigned int *expected, unsigned int desired)
0100 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
0101                                      __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
0102
0103 static inline int
0104 _Py_atomic_compare_exchange_uint8(uint8_t *obj, uint8_t *expected, uint8_t desired)
0105 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
0106                                      __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
0107
0108 static inline int
0109 _Py_atomic_compare_exchange_uint16(uint16_t *obj, uint16_t *expected, uint16_t desired)
0110 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
0111                                      __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
0112
0113 static inline int
0114 _Py_atomic_compare_exchange_uint32(uint32_t *obj, uint32_t *expected, uint32_t desired)
0115 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
0116                                      __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
0117
0118 static inline int
0119 _Py_atomic_compare_exchange_uint64(uint64_t *obj, uint64_t *expected, uint64_t desired)
0120 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
0121                                      __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
0122
0123 static inline int
0124 _Py_atomic_compare_exchange_uintptr(uintptr_t *obj, uintptr_t *expected, uintptr_t desired)
0125 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
0126                                      __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
0127
0128 static inline int
0129 _Py_atomic_compare_exchange_ssize(Py_ssize_t *obj, Py_ssize_t *expected, Py_ssize_t desired)
0130 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
0131                                      __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
0132
0133 static inline int
0134 _Py_atomic_compare_exchange_ptr(void *obj, void *expected, void *desired)
0135 { return __atomic_compare_exchange_n((void **)obj, (void **)expected, desired, 0,
0136                                      __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
0137
0138
0139 // --- _Py_atomic_exchange ---------------------------------------------------
0140
0141 static inline int
0142 _Py_atomic_exchange_int(int *obj, int value)
0143 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
0144
0145 static inline int8_t
0146 _Py_atomic_exchange_int8(int8_t *obj, int8_t value)
0147 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
0148
0149 static inline int16_t
0150 _Py_atomic_exchange_int16(int16_t *obj, int16_t value)
0151 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
0152
0153 static inline int32_t
0154 _Py_atomic_exchange_int32(int32_t *obj, int32_t value)
0155 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
0156
0157 static inline int64_t
0158 _Py_atomic_exchange_int64(int64_t *obj, int64_t value)
0159 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
0160
0161 static inline intptr_t
0162 _Py_atomic_exchange_intptr(intptr_t *obj, intptr_t value)
0163 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
0164
0165 static inline unsigned int
0166 _Py_atomic_exchange_uint(unsigned int *obj, unsigned int value)
0167 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
0168
0169 static inline uint8_t
0170 _Py_atomic_exchange_uint8(uint8_t *obj, uint8_t value)
0171 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
0172
0173 static inline uint16_t
0174 _Py_atomic_exchange_uint16(uint16_t *obj, uint16_t value)
0175 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
0176
0177 static inline uint32_t
0178 _Py_atomic_exchange_uint32(uint32_t *obj, uint32_t value)
0179 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
0180
0181 static inline uint64_t
0182 _Py_atomic_exchange_uint64(uint64_t *obj, uint64_t value)
0183 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
0184
0185 static inline uintptr_t
0186 _Py_atomic_exchange_uintptr(uintptr_t *obj, uintptr_t value)
0187 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
0188
0189 static inline Py_ssize_t
0190 _Py_atomic_exchange_ssize(Py_ssize_t *obj, Py_ssize_t value)
0191 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
0192
0193 static inline void *
0194 _Py_atomic_exchange_ptr(void *obj, void *value)
0195 { return __atomic_exchange_n((void **)obj, value, __ATOMIC_SEQ_CST); }
0196
0197
0198 // --- _Py_atomic_and --------------------------------------------------------
0199
0200 static inline uint8_t
0201 _Py_atomic_and_uint8(uint8_t *obj, uint8_t value)
0202 { return __atomic_fetch_and(obj, value, __ATOMIC_SEQ_CST); }
0203
0204 static inline uint16_t
0205 _Py_atomic_and_uint16(uint16_t *obj, uint16_t value)
0206 { return __atomic_fetch_and(obj, value, __ATOMIC_SEQ_CST); }
0207
0208 static inline uint32_t
0209 _Py_atomic_and_uint32(uint32_t *obj, uint32_t value)
0210 { return __atomic_fetch_and(obj, value, __ATOMIC_SEQ_CST); }
0211
0212 static inline uint64_t
0213 _Py_atomic_and_uint64(uint64_t *obj, uint64_t value)
0214 { return __atomic_fetch_and(obj, value, __ATOMIC_SEQ_CST); }
0215
0216 static inline uintptr_t
0217 _Py_atomic_and_uintptr(uintptr_t *obj, uintptr_t value)
0218 { return __atomic_fetch_and(obj, value, __ATOMIC_SEQ_CST); }
0219
0220
0221 // --- _Py_atomic_or ---------------------------------------------------------
0222
0223 static inline uint8_t
0224 _Py_atomic_or_uint8(uint8_t *obj, uint8_t value)
0225 { return __atomic_fetch_or(obj, value, __ATOMIC_SEQ_CST); }
0226
0227 static inline uint16_t
0228 _Py_atomic_or_uint16(uint16_t *obj, uint16_t value)
0229 { return __atomic_fetch_or(obj, value, __ATOMIC_SEQ_CST); }
0230
0231 static inline uint32_t
0232 _Py_atomic_or_uint32(uint32_t *obj, uint32_t value)
0233 { return __atomic_fetch_or(obj, value, __ATOMIC_SEQ_CST); }
0234
0235 static inline uint64_t
0236 _Py_atomic_or_uint64(uint64_t *obj, uint64_t value)
0237 { return __atomic_fetch_or(obj, value, __ATOMIC_SEQ_CST); }
0238
0239 static inline uintptr_t
0240 _Py_atomic_or_uintptr(uintptr_t *obj, uintptr_t value)
0241 { return __atomic_fetch_or(obj, value, __ATOMIC_SEQ_CST); }
0242
0243
0244 // --- _Py_atomic_load -------------------------------------------------------
0245
0246 static inline int
0247 _Py_atomic_load_int(const int *obj)
0248 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
0249
0250 static inline int8_t
0251 _Py_atomic_load_int8(const int8_t *obj)
0252 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
0253
0254 static inline int16_t
0255 _Py_atomic_load_int16(const int16_t *obj)
0256 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
0257
0258 static inline int32_t
0259 _Py_atomic_load_int32(const int32_t *obj)
0260 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
0261
0262 static inline int64_t
0263 _Py_atomic_load_int64(const int64_t *obj)
0264 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
0265
0266 static inline intptr_t
0267 _Py_atomic_load_intptr(const intptr_t *obj)
0268 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
0269
0270 static inline uint8_t
0271 _Py_atomic_load_uint8(const uint8_t *obj)
0272 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
0273
0274 static inline uint16_t
0275 _Py_atomic_load_uint16(const uint16_t *obj)
0276 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
0277
0278 static inline uint32_t
0279 _Py_atomic_load_uint32(const uint32_t *obj)
0280 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
0281
0282 static inline uint64_t
0283 _Py_atomic_load_uint64(const uint64_t *obj)
0284 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
0285
0286 static inline uintptr_t
0287 _Py_atomic_load_uintptr(const uintptr_t *obj)
0288 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
0289
0290 static inline unsigned int
0291 _Py_atomic_load_uint(const unsigned int *obj)
0292 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
0293
0294 static inline Py_ssize_t
0295 _Py_atomic_load_ssize(const Py_ssize_t *obj)
0296 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
0297
0298 static inline void *
0299 _Py_atomic_load_ptr(const void *obj)
0300 { return (void *)__atomic_load_n((void * const *)obj, __ATOMIC_SEQ_CST); }
0301
0302
0303 // --- _Py_atomic_load_relaxed -----------------------------------------------
0304
0305 static inline int
0306 _Py_atomic_load_int_relaxed(const int *obj)
0307 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
0308
0309 static inline int8_t
0310 _Py_atomic_load_int8_relaxed(const int8_t *obj)
0311 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
0312
0313 static inline int16_t
0314 _Py_atomic_load_int16_relaxed(const int16_t *obj)
0315 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
0316
0317 static inline int32_t
0318 _Py_atomic_load_int32_relaxed(const int32_t *obj)
0319 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
0320
0321 static inline int64_t
0322 _Py_atomic_load_int64_relaxed(const int64_t *obj)
0323 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
0324
0325 static inline intptr_t
0326 _Py_atomic_load_intptr_relaxed(const intptr_t *obj)
0327 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
0328
0329 static inline uint8_t
0330 _Py_atomic_load_uint8_relaxed(const uint8_t *obj)
0331 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
0332
0333 static inline uint16_t
0334 _Py_atomic_load_uint16_relaxed(const uint16_t *obj)
0335 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
0336
0337 static inline uint32_t
0338 _Py_atomic_load_uint32_relaxed(const uint32_t *obj)
0339 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
0340
0341 static inline uint64_t
0342 _Py_atomic_load_uint64_relaxed(const uint64_t *obj)
0343 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
0344
0345 static inline uintptr_t
0346 _Py_atomic_load_uintptr_relaxed(const uintptr_t *obj)
0347 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
0348
0349 static inline unsigned int
0350 _Py_atomic_load_uint_relaxed(const unsigned int *obj)
0351 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
0352
0353 static inline Py_ssize_t
0354 _Py_atomic_load_ssize_relaxed(const Py_ssize_t *obj)
0355 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
0356
0357 static inline void *
0358 _Py_atomic_load_ptr_relaxed(const void *obj)
0359 { return (void *)__atomic_load_n((void * const *)obj, __ATOMIC_RELAXED); }
0360
0361 static inline unsigned long long
0362 _Py_atomic_load_ullong_relaxed(const unsigned long long *obj)
0363 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
0364
0365
0366 // --- _Py_atomic_store ------------------------------------------------------
0367
0368 static inline void
0369 _Py_atomic_store_int(int *obj, int value)
0370 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
0371
0372 static inline void
0373 _Py_atomic_store_int8(int8_t *obj, int8_t value)
0374 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
0375
0376 static inline void
0377 _Py_atomic_store_int16(int16_t *obj, int16_t value)
0378 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
0379
0380 static inline void
0381 _Py_atomic_store_int32(int32_t *obj, int32_t value)
0382 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
0383
0384 static inline void
0385 _Py_atomic_store_int64(int64_t *obj, int64_t value)
0386 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
0387
0388 static inline void
0389 _Py_atomic_store_intptr(intptr_t *obj, intptr_t value)
0390 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
0391
0392 static inline void
0393 _Py_atomic_store_uint8(uint8_t *obj, uint8_t value)
0394 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
0395
0396 static inline void
0397 _Py_atomic_store_uint16(uint16_t *obj, uint16_t value)
0398 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
0399
0400 static inline void
0401 _Py_atomic_store_uint32(uint32_t *obj, uint32_t value)
0402 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
0403
0404 static inline void
0405 _Py_atomic_store_uint64(uint64_t *obj, uint64_t value)
0406 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
0407
0408 static inline void
0409 _Py_atomic_store_uintptr(uintptr_t *obj, uintptr_t value)
0410 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
0411
0412 static inline void
0413 _Py_atomic_store_uint(unsigned int *obj, unsigned int value)
0414 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
0415
0416 static inline void
0417 _Py_atomic_store_ptr(void *obj, void *value)
0418 { __atomic_store_n((void **)obj, value, __ATOMIC_SEQ_CST); }
0419
0420 static inline void
0421 _Py_atomic_store_ssize(Py_ssize_t *obj, Py_ssize_t value)
0422 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
0423
0424
0425 // --- _Py_atomic_store_relaxed ----------------------------------------------
0426
0427 static inline void
0428 _Py_atomic_store_int_relaxed(int *obj, int value)
0429 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
0430
0431 static inline void
0432 _Py_atomic_store_int8_relaxed(int8_t *obj, int8_t value)
0433 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
0434
0435 static inline void
0436 _Py_atomic_store_int16_relaxed(int16_t *obj, int16_t value)
0437 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
0438
0439 static inline void
0440 _Py_atomic_store_int32_relaxed(int32_t *obj, int32_t value)
0441 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
0442
0443 static inline void
0444 _Py_atomic_store_int64_relaxed(int64_t *obj, int64_t value)
0445 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
0446
0447 static inline void
0448 _Py_atomic_store_intptr_relaxed(intptr_t *obj, intptr_t value)
0449 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
0450
0451 static inline void
0452 _Py_atomic_store_uint8_relaxed(uint8_t *obj, uint8_t value)
0453 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
0454
0455 static inline void
0456 _Py_atomic_store_uint16_relaxed(uint16_t *obj, uint16_t value)
0457 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
0458
0459 static inline void
0460 _Py_atomic_store_uint32_relaxed(uint32_t *obj, uint32_t value)
0461 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
0462
0463 static inline void
0464 _Py_atomic_store_uint64_relaxed(uint64_t *obj, uint64_t value)
0465 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
0466
0467 static inline void
0468 _Py_atomic_store_uintptr_relaxed(uintptr_t *obj, uintptr_t value)
0469 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
0470
0471 static inline void
0472 _Py_atomic_store_uint_relaxed(unsigned int *obj, unsigned int value)
0473 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
0474
0475 static inline void
0476 _Py_atomic_store_ptr_relaxed(void *obj, void *value)
0477 { __atomic_store_n((void **)obj, value, __ATOMIC_RELAXED); }
0478
0479 static inline void
0480 _Py_atomic_store_ssize_relaxed(Py_ssize_t *obj, Py_ssize_t value)
0481 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
0482
0483 static inline void
0484 _Py_atomic_store_ullong_relaxed(unsigned long long *obj,
0485                                 unsigned long long value)
0486 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
0487
0488
0489 // --- _Py_atomic_load_ptr_acquire / _Py_atomic_store_ptr_release ------------
0490
0491 static inline void *
0492 _Py_atomic_load_ptr_acquire(const void *obj)
0493 { return (void *)__atomic_load_n((void * const *)obj, __ATOMIC_ACQUIRE); }
0494
0495 static inline uintptr_t
0496 _Py_atomic_load_uintptr_acquire(const uintptr_t *obj)
0497 { return (uintptr_t)__atomic_load_n(obj, __ATOMIC_ACQUIRE); }
0498
0499 static inline void
0500 _Py_atomic_store_ptr_release(void *obj, void *value)
0501 { __atomic_store_n((void **)obj, value, __ATOMIC_RELEASE); }
0502
0503 static inline void
0504 _Py_atomic_store_uintptr_release(uintptr_t *obj, uintptr_t value)
0505 { __atomic_store_n(obj, value, __ATOMIC_RELEASE); }
0506
0507 static inline void
0508 _Py_atomic_store_int_release(int *obj, int value)
0509 { __atomic_store_n(obj, value, __ATOMIC_RELEASE); }
0510
0511 static inline void
0512 _Py_atomic_store_ssize_release(Py_ssize_t *obj, Py_ssize_t value)
0513 { __atomic_store_n(obj, value, __ATOMIC_RELEASE); }
0514
0515 static inline int
0516 _Py_atomic_load_int_acquire(const int *obj)
0517 { return __atomic_load_n(obj, __ATOMIC_ACQUIRE); }
0518
0519 static inline void
0520 _Py_atomic_store_uint32_release(uint32_t *obj, uint32_t value)
0521 { __atomic_store_n(obj, value, __ATOMIC_RELEASE); }
0522
0523 static inline void
0524 _Py_atomic_store_uint64_release(uint64_t *obj, uint64_t value)
0525 { __atomic_store_n(obj, value, __ATOMIC_RELEASE); }
0526
0527 static inline uint64_t
0528 _Py_atomic_load_uint64_acquire(const uint64_t *obj)
0529 { return __atomic_load_n(obj, __ATOMIC_ACQUIRE); }
0530
0531 static inline uint32_t
0532 _Py_atomic_load_uint32_acquire(const uint32_t *obj)
0533 { return __atomic_load_n(obj, __ATOMIC_ACQUIRE); }
0534
0535 static inline Py_ssize_t
0536 _Py_atomic_load_ssize_acquire(const Py_ssize_t *obj)
0537 { return __atomic_load_n(obj, __ATOMIC_ACQUIRE); }
0538
0539 // --- _Py_atomic_fence ------------------------------------------------------
0540
0541 static inline void
0542 _Py_atomic_fence_seq_cst(void)
0543 { __atomic_thread_fence(__ATOMIC_SEQ_CST); }
0544
0545  static inline void
0546 _Py_atomic_fence_acquire(void)
0547 { __atomic_thread_fence(__ATOMIC_ACQUIRE); }
0548
0549  static inline void
0550 _Py_atomic_fence_release(void)
0551 { __atomic_thread_fence(__ATOMIC_RELEASE); }