| /* Copyright (C) 2003-2018 Free Software Foundation, Inc. |
| This file is part of the GNU C Library. |
| Contributed by Martin Schwidefsky <schwidefsky@de.ibm.com>, 2003. |
| |
| The GNU C Library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Lesser General Public |
| License as published by the Free Software Foundation; either |
| version 2.1 of the License, or (at your option) any later version. |
| |
| The GNU C Library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public |
| License along with the GNU C Library; if not, see |
| <http://www.gnu.org/licenses/>. */ |
| |
| #include <stdint.h> |
| |
| typedef int8_t atomic8_t; |
| typedef uint8_t uatomic8_t; |
| typedef int_fast8_t atomic_fast8_t; |
| typedef uint_fast8_t uatomic_fast8_t; |
| |
| typedef int16_t atomic16_t; |
| typedef uint16_t uatomic16_t; |
| typedef int_fast16_t atomic_fast16_t; |
| typedef uint_fast16_t uatomic_fast16_t; |
| |
| typedef int32_t atomic32_t; |
| typedef uint32_t uatomic32_t; |
| typedef int_fast32_t atomic_fast32_t; |
| typedef uint_fast32_t uatomic_fast32_t; |
| |
| typedef int64_t atomic64_t; |
| typedef uint64_t uatomic64_t; |
| typedef int_fast64_t atomic_fast64_t; |
| typedef uint_fast64_t uatomic_fast64_t; |
| |
| typedef intptr_t atomicptr_t; |
| typedef uintptr_t uatomicptr_t; |
| typedef intmax_t atomic_max_t; |
| typedef uintmax_t uatomic_max_t; |
| |
| /* Activate all C11 atomic builtins. |
| |
| Note: |
| E.g. in nptl/pthread_key_delete.c if compiled with GCCs 6 and before, |
| an extra stack-frame is generated and the old value is stored on stack |
| before cs instruction but it never loads this value from stack. |
| An unreleased GCC 7 omit those stack operations. |
| |
| E.g. in nptl/pthread_once.c the condition code of cs instruction is |
| evaluated by a sequence of ipm, sra, compare and jump instructions instead |
| of one conditional jump instruction. This also occurs with an unreleased |
| GCC 7. |
| |
| The atomic_fetch_abc_def C11 builtins are now using load-and-abc instructions |
| on z196 zarch and higher cpus instead of a loop with compare-and-swap |
| instruction. */ |
| #define USE_ATOMIC_COMPILER_BUILTINS 1 |
| |
| #ifdef __s390x__ |
| # define __HAVE_64B_ATOMICS 1 |
| #else |
| # define __HAVE_64B_ATOMICS 0 |
| #endif |
| |
| #define ATOMIC_EXCHANGE_USES_CAS 1 |
| |
| /* Implement some of the non-C11 atomic macros from include/atomic.h |
| with help of the C11 atomic builtins. The other non-C11 atomic macros |
| are using the macros defined here. */ |
| |
| /* Atomically store NEWVAL in *MEM if *MEM is equal to OLDVAL. |
| Return the old *MEM value. */ |
| #define atomic_compare_and_exchange_val_acq(mem, newval, oldval) \ |
| ({ __atomic_check_size((mem)); \ |
| typeof ((__typeof (*(mem))) *(mem)) __atg1_oldval = (oldval); \ |
| __atomic_compare_exchange_n (mem, (void *) &__atg1_oldval, \ |
| newval, 1, __ATOMIC_ACQUIRE, \ |
| __ATOMIC_RELAXED); \ |
| __atg1_oldval; }) |
| #define atomic_compare_and_exchange_val_rel(mem, newval, oldval) \ |
| ({ __atomic_check_size((mem)); \ |
| typeof ((__typeof (*(mem))) *(mem)) __atg1_2_oldval = (oldval); \ |
| __atomic_compare_exchange_n (mem, (void *) &__atg1_2_oldval, \ |
| newval, 1, __ATOMIC_RELEASE, \ |
| __ATOMIC_RELAXED); \ |
| __atg1_2_oldval; }) |
| |
| /* Atomically store NEWVAL in *MEM if *MEM is equal to OLDVAL. |
| Return zero if *MEM was changed or non-zero if no exchange happened. */ |
| #define atomic_compare_and_exchange_bool_acq(mem, newval, oldval) \ |
| ({ __atomic_check_size((mem)); \ |
| typeof ((__typeof (*(mem))) *(mem)) __atg2_oldval = (oldval); \ |
| !__atomic_compare_exchange_n (mem, (void *) &__atg2_oldval, newval, \ |
| 1, __ATOMIC_ACQUIRE, \ |
| __ATOMIC_RELAXED); }) |
| #define catomic_compare_and_exchange_bool_acq(mem, newval, oldval) \ |
| atomic_compare_and_exchange_bool_acq (mem, newval, oldval) |
| |
| /* Store NEWVALUE in *MEM and return the old value. */ |
| #define atomic_exchange_acq(mem, newvalue) \ |
| ({ __atomic_check_size((mem)); \ |
| __atomic_exchange_n (mem, newvalue, __ATOMIC_ACQUIRE); }) |
| #define atomic_exchange_rel(mem, newvalue) \ |
| ({ __atomic_check_size((mem)); \ |
| __atomic_exchange_n (mem, newvalue, __ATOMIC_RELEASE); }) |
| |
| /* Add VALUE to *MEM and return the old value of *MEM. */ |
| /* The gcc builtin uses load-and-add instruction on z196 zarch and higher cpus |
| instead of a loop with compare-and-swap instruction. */ |
| # define atomic_exchange_and_add_acq(mem, operand) \ |
| ({ __atomic_check_size((mem)); \ |
| __atomic_fetch_add ((mem), (operand), __ATOMIC_ACQUIRE); }) |
| # define atomic_exchange_and_add_rel(mem, operand) \ |
| ({ __atomic_check_size((mem)); \ |
| __atomic_fetch_add ((mem), (operand), __ATOMIC_RELEASE); }) |
| #define catomic_exchange_and_add(mem, value) \ |
| atomic_exchange_and_add (mem, value) |
| |
| /* Atomically *mem |= mask and return the old value of *mem. */ |
| /* The gcc builtin uses load-and-or instruction on z196 zarch and higher cpus |
| instead of a loop with compare-and-swap instruction. */ |
| #define atomic_or_val(mem, operand) \ |
| ({ __atomic_check_size((mem)); \ |
| __atomic_fetch_or ((mem), (operand), __ATOMIC_ACQUIRE); }) |
| /* Atomically *mem |= mask. */ |
| #define atomic_or(mem, mask) \ |
| do { \ |
| atomic_or_val (mem, mask); \ |
| } while (0) |
| #define catomic_or(mem, mask) \ |
| atomic_or (mem, mask) |
| |
| /* Atomically *mem |= 1 << bit and return true if the bit was set in old value |
| of *mem. */ |
| /* The load-and-or instruction is used on z196 zarch and higher cpus |
| instead of a loop with compare-and-swap instruction. */ |
| #define atomic_bit_test_set(mem, bit) \ |
| ({ __typeof (*(mem)) __atg14_old; \ |
| __typeof (mem) __atg14_memp = (mem); \ |
| __typeof (*(mem)) __atg14_mask = ((__typeof (*(mem))) 1 << (bit)); \ |
| __atg14_old = atomic_or_val (__atg14_memp, __atg14_mask); \ |
| __atg14_old & __atg14_mask; }) |
| |
| /* Atomically *mem &= mask and return the old value of *mem. */ |
| /* The gcc builtin uses load-and-and instruction on z196 zarch and higher cpus |
| instead of a loop with compare-and-swap instruction. */ |
| #define atomic_and_val(mem, operand) \ |
| ({ __atomic_check_size((mem)); \ |
| __atomic_fetch_and ((mem), (operand), __ATOMIC_ACQUIRE); }) |
| /* Atomically *mem &= mask. */ |
| #define atomic_and(mem, mask) \ |
| do { \ |
| atomic_and_val (mem, mask); \ |
| } while (0) |
| #define catomic_and(mem, mask) \ |
| atomic_and(mem, mask) |