Debian Codegraph @

Include/cpython/pyatomic_gcc.h

raw
1 // This is the implementation of Python atomic operations using GCC's built-in
2 // functions that match the C+11 memory model. This implementation is preferred
3 // for GCC compatible compilers, such as Clang. These functions are available
4 // in GCC 4.8+ without needing to compile with --std=c11 or --std=gnu11.
5
6 #ifndef Py_ATOMIC_GCC_H
7 # error "this header file must not be included directly"
8 #endif
9
10
11 // --- _Py_atomic_add --------------------------------------------------------
12
13 static inline int
14 _Py_atomic_add_int(int *obj, int value)
15 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
16
17 static inline int8_t
18 _Py_atomic_add_int8(int8_t *obj, int8_t value)
19 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
20
21 static inline int16_t
22 _Py_atomic_add_int16(int16_t *obj, int16_t value)
23 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
24
25 static inline int32_t
26 _Py_atomic_add_int32(int32_t *obj, int32_t value)
27 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
28
29 static inline int64_t
30 _Py_atomic_add_int64(int64_t *obj, int64_t value)
31 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
32
33 static inline intptr_t
34 _Py_atomic_add_intptr(intptr_t *obj, intptr_t value)
35 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
36
37 static inline unsigned int
38 _Py_atomic_add_uint(unsigned int *obj, unsigned int value)
39 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
40
41 static inline uint8_t
42 _Py_atomic_add_uint8(uint8_t *obj, uint8_t value)
43 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
44
45 static inline uint16_t
46 _Py_atomic_add_uint16(uint16_t *obj, uint16_t value)
47 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
48
49 static inline uint32_t
50 _Py_atomic_add_uint32(uint32_t *obj, uint32_t value)
51 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
52
53 static inline uint64_t
54 _Py_atomic_add_uint64(uint64_t *obj, uint64_t value)
55 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
56
57 static inline uintptr_t
58 _Py_atomic_add_uintptr(uintptr_t *obj, uintptr_t value)
59 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
60
61 static inline Py_ssize_t
62 _Py_atomic_add_ssize(Py_ssize_t *obj, Py_ssize_t value)
63 { return __atomic_fetch_add(obj, value, __ATOMIC_SEQ_CST); }
64
65
66 // --- _Py_atomic_compare_exchange -------------------------------------------
67
68 static inline int
69 _Py_atomic_compare_exchange_int(int *obj, int *expected, int desired)
70 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
71 __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
72
73 static inline int
74 _Py_atomic_compare_exchange_int8(int8_t *obj, int8_t *expected, int8_t desired)
75 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
76 __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
77
78 static inline int
79 _Py_atomic_compare_exchange_int16(int16_t *obj, int16_t *expected, int16_t desired)
80 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
81 __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
82
83 static inline int
84 _Py_atomic_compare_exchange_int32(int32_t *obj, int32_t *expected, int32_t desired)
85 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
86 __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
87
88 static inline int
89 _Py_atomic_compare_exchange_int64(int64_t *obj, int64_t *expected, int64_t desired)
90 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
91 __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
92
93 static inline int
94 _Py_atomic_compare_exchange_intptr(intptr_t *obj, intptr_t *expected, intptr_t desired)
95 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
96 __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
97
98 static inline int
99 _Py_atomic_compare_exchange_uint(unsigned int *obj, unsigned int *expected, unsigned int desired)
100 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
101 __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
102
103 static inline int
104 _Py_atomic_compare_exchange_uint8(uint8_t *obj, uint8_t *expected, uint8_t desired)
105 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
106 __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
107
108 static inline int
109 _Py_atomic_compare_exchange_uint16(uint16_t *obj, uint16_t *expected, uint16_t desired)
110 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
111 __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
112
113 static inline int
114 _Py_atomic_compare_exchange_uint32(uint32_t *obj, uint32_t *expected, uint32_t desired)
115 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
116 __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
117
118 static inline int
119 _Py_atomic_compare_exchange_uint64(uint64_t *obj, uint64_t *expected, uint64_t desired)
120 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
121 __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
122
123 static inline int
124 _Py_atomic_compare_exchange_uintptr(uintptr_t *obj, uintptr_t *expected, uintptr_t desired)
125 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
126 __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
127
128 static inline int
129 _Py_atomic_compare_exchange_ssize(Py_ssize_t *obj, Py_ssize_t *expected, Py_ssize_t desired)
130 { return __atomic_compare_exchange_n(obj, expected, desired, 0,
131 __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
132
133 static inline int
134 _Py_atomic_compare_exchange_ptr(void *obj, void *expected, void *desired)
135 { return __atomic_compare_exchange_n((void **)obj, (void **)expected, desired, 0,
136 __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST); }
137
138
139 // --- _Py_atomic_exchange ---------------------------------------------------
140
141 static inline int
142 _Py_atomic_exchange_int(int *obj, int value)
143 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
144
145 static inline int8_t
146 _Py_atomic_exchange_int8(int8_t *obj, int8_t value)
147 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
148
149 static inline int16_t
150 _Py_atomic_exchange_int16(int16_t *obj, int16_t value)
151 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
152
153 static inline int32_t
154 _Py_atomic_exchange_int32(int32_t *obj, int32_t value)
155 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
156
157 static inline int64_t
158 _Py_atomic_exchange_int64(int64_t *obj, int64_t value)
159 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
160
161 static inline intptr_t
162 _Py_atomic_exchange_intptr(intptr_t *obj, intptr_t value)
163 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
164
165 static inline unsigned int
166 _Py_atomic_exchange_uint(unsigned int *obj, unsigned int value)
167 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
168
169 static inline uint8_t
170 _Py_atomic_exchange_uint8(uint8_t *obj, uint8_t value)
171 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
172
173 static inline uint16_t
174 _Py_atomic_exchange_uint16(uint16_t *obj, uint16_t value)
175 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
176
177 static inline uint32_t
178 _Py_atomic_exchange_uint32(uint32_t *obj, uint32_t value)
179 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
180
181 static inline uint64_t
182 _Py_atomic_exchange_uint64(uint64_t *obj, uint64_t value)
183 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
184
185 static inline uintptr_t
186 _Py_atomic_exchange_uintptr(uintptr_t *obj, uintptr_t value)
187 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
188
189 static inline Py_ssize_t
190 _Py_atomic_exchange_ssize(Py_ssize_t *obj, Py_ssize_t value)
191 { return __atomic_exchange_n(obj, value, __ATOMIC_SEQ_CST); }
192
193 static inline void *
194 _Py_atomic_exchange_ptr(void *obj, void *value)
195 { return __atomic_exchange_n((void **)obj, value, __ATOMIC_SEQ_CST); }
196
197
198 // --- _Py_atomic_and --------------------------------------------------------
199
200 static inline uint8_t
201 _Py_atomic_and_uint8(uint8_t *obj, uint8_t value)
202 { return __atomic_fetch_and(obj, value, __ATOMIC_SEQ_CST); }
203
204 static inline uint16_t
205 _Py_atomic_and_uint16(uint16_t *obj, uint16_t value)
206 { return __atomic_fetch_and(obj, value, __ATOMIC_SEQ_CST); }
207
208 static inline uint32_t
209 _Py_atomic_and_uint32(uint32_t *obj, uint32_t value)
210 { return __atomic_fetch_and(obj, value, __ATOMIC_SEQ_CST); }
211
212 static inline uint64_t
213 _Py_atomic_and_uint64(uint64_t *obj, uint64_t value)
214 { return __atomic_fetch_and(obj, value, __ATOMIC_SEQ_CST); }
215
216 static inline uintptr_t
217 _Py_atomic_and_uintptr(uintptr_t *obj, uintptr_t value)
218 { return __atomic_fetch_and(obj, value, __ATOMIC_SEQ_CST); }
219
220
221 // --- _Py_atomic_or ---------------------------------------------------------
222
223 static inline uint8_t
224 _Py_atomic_or_uint8(uint8_t *obj, uint8_t value)
225 { return __atomic_fetch_or(obj, value, __ATOMIC_SEQ_CST); }
226
227 static inline uint16_t
228 _Py_atomic_or_uint16(uint16_t *obj, uint16_t value)
229 { return __atomic_fetch_or(obj, value, __ATOMIC_SEQ_CST); }
230
231 static inline uint32_t
232 _Py_atomic_or_uint32(uint32_t *obj, uint32_t value)
233 { return __atomic_fetch_or(obj, value, __ATOMIC_SEQ_CST); }
234
235 static inline uint64_t
236 _Py_atomic_or_uint64(uint64_t *obj, uint64_t value)
237 { return __atomic_fetch_or(obj, value, __ATOMIC_SEQ_CST); }
238
239 static inline uintptr_t
240 _Py_atomic_or_uintptr(uintptr_t *obj, uintptr_t value)
241 { return __atomic_fetch_or(obj, value, __ATOMIC_SEQ_CST); }
242
243
244 // --- _Py_atomic_load -------------------------------------------------------
245
246 static inline int
247 _Py_atomic_load_int(const int *obj)
248 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
249
250 static inline int8_t
251 _Py_atomic_load_int8(const int8_t *obj)
252 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
253
254 static inline int16_t
255 _Py_atomic_load_int16(const int16_t *obj)
256 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
257
258 static inline int32_t
259 _Py_atomic_load_int32(const int32_t *obj)
260 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
261
262 static inline int64_t
263 _Py_atomic_load_int64(const int64_t *obj)
264 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
265
266 static inline intptr_t
267 _Py_atomic_load_intptr(const intptr_t *obj)
268 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
269
270 static inline uint8_t
271 _Py_atomic_load_uint8(const uint8_t *obj)
272 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
273
274 static inline uint16_t
275 _Py_atomic_load_uint16(const uint16_t *obj)
276 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
277
278 static inline uint32_t
279 _Py_atomic_load_uint32(const uint32_t *obj)
280 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
281
282 static inline uint64_t
283 _Py_atomic_load_uint64(const uint64_t *obj)
284 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
285
286 static inline uintptr_t
287 _Py_atomic_load_uintptr(const uintptr_t *obj)
288 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
289
290 static inline unsigned int
291 _Py_atomic_load_uint(const unsigned int *obj)
292 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
293
294 static inline Py_ssize_t
295 _Py_atomic_load_ssize(const Py_ssize_t *obj)
296 { return __atomic_load_n(obj, __ATOMIC_SEQ_CST); }
297
298 static inline void *
299 _Py_atomic_load_ptr(const void *obj)
300 { return (void *)__atomic_load_n((void * const *)obj, __ATOMIC_SEQ_CST); }
301
302
303 // --- _Py_atomic_load_relaxed -----------------------------------------------
304
305 static inline int
306 _Py_atomic_load_int_relaxed(const int *obj)
307 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
308
309 static inline char
310 _Py_atomic_load_char_relaxed(const char *obj)
311 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
312
313 static inline unsigned char
314 _Py_atomic_load_uchar_relaxed(const unsigned char *obj)
315 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
316
317 static inline short
318 _Py_atomic_load_short_relaxed(const short *obj)
319 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
320
321 static inline unsigned short
322 _Py_atomic_load_ushort_relaxed(const unsigned short *obj)
323 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
324
325 static inline long
326 _Py_atomic_load_long_relaxed(const long *obj)
327 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
328
329 static inline float
330 _Py_atomic_load_float_relaxed(const float *obj)
331 { float ret; __atomic_load(obj, &ret, __ATOMIC_RELAXED); return ret; }
332
333 static inline double
334 _Py_atomic_load_double_relaxed(const double *obj)
335 { double ret; __atomic_load(obj, &ret, __ATOMIC_RELAXED); return ret; }
336
337 static inline int8_t
338 _Py_atomic_load_int8_relaxed(const int8_t *obj)
339 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
340
341 static inline int16_t
342 _Py_atomic_load_int16_relaxed(const int16_t *obj)
343 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
344
345 static inline int32_t
346 _Py_atomic_load_int32_relaxed(const int32_t *obj)
347 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
348
349 static inline int64_t
350 _Py_atomic_load_int64_relaxed(const int64_t *obj)
351 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
352
353 static inline intptr_t
354 _Py_atomic_load_intptr_relaxed(const intptr_t *obj)
355 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
356
357 static inline uint8_t
358 _Py_atomic_load_uint8_relaxed(const uint8_t *obj)
359 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
360
361 static inline uint16_t
362 _Py_atomic_load_uint16_relaxed(const uint16_t *obj)
363 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
364
365 static inline uint32_t
366 _Py_atomic_load_uint32_relaxed(const uint32_t *obj)
367 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
368
369 static inline uint64_t
370 _Py_atomic_load_uint64_relaxed(const uint64_t *obj)
371 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
372
373 static inline uintptr_t
374 _Py_atomic_load_uintptr_relaxed(const uintptr_t *obj)
375 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
376
377 static inline unsigned int
378 _Py_atomic_load_uint_relaxed(const unsigned int *obj)
379 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
380
381 static inline Py_ssize_t
382 _Py_atomic_load_ssize_relaxed(const Py_ssize_t *obj)
383 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
384
385 static inline void *
386 _Py_atomic_load_ptr_relaxed(const void *obj)
387 { return (void *)__atomic_load_n((void * const *)obj, __ATOMIC_RELAXED); }
388
389 static inline unsigned long long
390 _Py_atomic_load_ullong_relaxed(const unsigned long long *obj)
391 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
392
393 static inline long long
394 _Py_atomic_load_llong_relaxed(const long long *obj)
395 { return __atomic_load_n(obj, __ATOMIC_RELAXED); }
396
397
398 // --- _Py_atomic_store ------------------------------------------------------
399
400 static inline void
401 _Py_atomic_store_int(int *obj, int value)
402 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
403
404 static inline void
405 _Py_atomic_store_int8(int8_t *obj, int8_t value)
406 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
407
408 static inline void
409 _Py_atomic_store_int16(int16_t *obj, int16_t value)
410 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
411
412 static inline void
413 _Py_atomic_store_int32(int32_t *obj, int32_t value)
414 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
415
416 static inline void
417 _Py_atomic_store_int64(int64_t *obj, int64_t value)
418 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
419
420 static inline void
421 _Py_atomic_store_intptr(intptr_t *obj, intptr_t value)
422 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
423
424 static inline void
425 _Py_atomic_store_uint8(uint8_t *obj, uint8_t value)
426 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
427
428 static inline void
429 _Py_atomic_store_uint16(uint16_t *obj, uint16_t value)
430 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
431
432 static inline void
433 _Py_atomic_store_uint32(uint32_t *obj, uint32_t value)
434 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
435
436 static inline void
437 _Py_atomic_store_uint64(uint64_t *obj, uint64_t value)
438 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
439
440 static inline void
441 _Py_atomic_store_uintptr(uintptr_t *obj, uintptr_t value)
442 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
443
444 static inline void
445 _Py_atomic_store_uint(unsigned int *obj, unsigned int value)
446 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
447
448 static inline void
449 _Py_atomic_store_ptr(void *obj, void *value)
450 { __atomic_store_n((void **)obj, value, __ATOMIC_SEQ_CST); }
451
452 static inline void
453 _Py_atomic_store_ssize(Py_ssize_t *obj, Py_ssize_t value)
454 { __atomic_store_n(obj, value, __ATOMIC_SEQ_CST); }
455
456
457 // --- _Py_atomic_store_relaxed ----------------------------------------------
458
459 static inline void
460 _Py_atomic_store_int_relaxed(int *obj, int value)
461 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
462
463 static inline void
464 _Py_atomic_store_int8_relaxed(int8_t *obj, int8_t value)
465 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
466
467 static inline void
468 _Py_atomic_store_int16_relaxed(int16_t *obj, int16_t value)
469 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
470
471 static inline void
472 _Py_atomic_store_int32_relaxed(int32_t *obj, int32_t value)
473 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
474
475 static inline void
476 _Py_atomic_store_int64_relaxed(int64_t *obj, int64_t value)
477 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
478
479 static inline void
480 _Py_atomic_store_intptr_relaxed(intptr_t *obj, intptr_t value)
481 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
482
483 static inline void
484 _Py_atomic_store_uint8_relaxed(uint8_t *obj, uint8_t value)
485 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
486
487 static inline void
488 _Py_atomic_store_uint16_relaxed(uint16_t *obj, uint16_t value)
489 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
490
491 static inline void
492 _Py_atomic_store_uint32_relaxed(uint32_t *obj, uint32_t value)
493 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
494
495 static inline void
496 _Py_atomic_store_uint64_relaxed(uint64_t *obj, uint64_t value)
497 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
498
499 static inline void
500 _Py_atomic_store_uintptr_relaxed(uintptr_t *obj, uintptr_t value)
501 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
502
503 static inline void
504 _Py_atomic_store_uint_relaxed(unsigned int *obj, unsigned int value)
505 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
506
507 static inline void
508 _Py_atomic_store_ptr_relaxed(void *obj, void *value)
509 { __atomic_store_n((void **)obj, value, __ATOMIC_RELAXED); }
510
511 static inline void
512 _Py_atomic_store_ssize_relaxed(Py_ssize_t *obj, Py_ssize_t value)
513 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
514
515 static inline void
516 _Py_atomic_store_ullong_relaxed(unsigned long long *obj,
517 unsigned long long value)
518 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
519
520 static inline void
521 _Py_atomic_store_char_relaxed(char *obj, char value)
522 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
523
524 static inline void
525 _Py_atomic_store_uchar_relaxed(unsigned char *obj, unsigned char value)
526 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
527
528 static inline void
529 _Py_atomic_store_short_relaxed(short *obj, short value)
530 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
531
532 static inline void
533 _Py_atomic_store_ushort_relaxed(unsigned short *obj, unsigned short value)
534 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
535
536 static inline void
537 _Py_atomic_store_long_relaxed(long *obj, long value)
538 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
539
540 static inline void
541 _Py_atomic_store_float_relaxed(float *obj, float value)
542 { __atomic_store(obj, &value, __ATOMIC_RELAXED); }
543
544 static inline void
545 _Py_atomic_store_double_relaxed(double *obj, double value)
546 { __atomic_store(obj, &value, __ATOMIC_RELAXED); }
547
548 static inline void
549 _Py_atomic_store_llong_relaxed(long long *obj, long long value)
550 { __atomic_store_n(obj, value, __ATOMIC_RELAXED); }
551
552
553 // --- _Py_atomic_load_ptr_acquire / _Py_atomic_store_ptr_release ------------
554
555 static inline void *
556 _Py_atomic_load_ptr_acquire(const void *obj)
557 { return (void *)__atomic_load_n((void * const *)obj, __ATOMIC_ACQUIRE); }
558
559 static inline uintptr_t
560 _Py_atomic_load_uintptr_acquire(const uintptr_t *obj)
561 { return (uintptr_t)__atomic_load_n(obj, __ATOMIC_ACQUIRE); }
562
563 static inline void
564 _Py_atomic_store_ptr_release(void *obj, void *value)
565 { __atomic_store_n((void **)obj, value, __ATOMIC_RELEASE); }
566
567 static inline void
568 _Py_atomic_store_uintptr_release(uintptr_t *obj, uintptr_t value)
569 { __atomic_store_n(obj, value, __ATOMIC_RELEASE); }
570
571 static inline void
572 _Py_atomic_store_int_release(int *obj, int value)
573 { __atomic_store_n(obj, value, __ATOMIC_RELEASE); }
574
575 static inline void
576 _Py_atomic_store_ssize_release(Py_ssize_t *obj, Py_ssize_t value)
577 { __atomic_store_n(obj, value, __ATOMIC_RELEASE); }
578
579 static inline void
580 _Py_atomic_store_uint_release(unsigned int *obj, unsigned int value)
581 { __atomic_store_n(obj, value, __ATOMIC_RELEASE); }
582
583 static inline int
584 _Py_atomic_load_int_acquire(const int *obj)
585 { return __atomic_load_n(obj, __ATOMIC_ACQUIRE); }
586
587 static inline void
588 _Py_atomic_store_uint32_release(uint32_t *obj, uint32_t value)
589 { __atomic_store_n(obj, value, __ATOMIC_RELEASE); }
590
591 static inline void
592 _Py_atomic_store_uint64_release(uint64_t *obj, uint64_t value)
593 { __atomic_store_n(obj, value, __ATOMIC_RELEASE); }
594
595 static inline uint64_t
596 _Py_atomic_load_uint64_acquire(const uint64_t *obj)
597 { return __atomic_load_n(obj, __ATOMIC_ACQUIRE); }
598
599 static inline uint32_t
600 _Py_atomic_load_uint32_acquire(const uint32_t *obj)
601 { return __atomic_load_n(obj, __ATOMIC_ACQUIRE); }
602
603 static inline Py_ssize_t
604 _Py_atomic_load_ssize_acquire(const Py_ssize_t *obj)
605 { return __atomic_load_n(obj, __ATOMIC_ACQUIRE); }
606
607 // --- _Py_atomic_fence ------------------------------------------------------
608
609 static inline void
610 _Py_atomic_fence_seq_cst(void)
611 { __atomic_thread_fence(__ATOMIC_SEQ_CST); }
612
613 static inline void
614 _Py_atomic_fence_acquire(void)
615 { __atomic_thread_fence(__ATOMIC_ACQUIRE); }
616
617 static inline void
618 _Py_atomic_fence_release(void)
619 { __atomic_thread_fence(__ATOMIC_RELEASE); }