From 4009bf404450e4ad7b72140d7bae3226fad3468c Mon Sep 17 00:00:00 2001 From: Ulrich Drepper Date: Thu, 20 Mar 2003 07:19:17 +0000 Subject: Update. 2003-03-19 Ulrich Drepper * Makefile (distribute): Add include/atomic.h and bits/atomic.h. * include/atomic.h: New file. * sysdeps/i386/i486/bits/atomic.h: New file. * sysdeps/x86_64/bits/atomic.h: New file. * sysdeps/s390/bits/atomic.h: New file. * sysdeps/sh/bits/atomic.h: New file. * sysdeps/ia64/bits/atomic.h: New file. * sysdeps/powerpc/bits/atomic.h: New file. * sysdeps/generic/bits/atomic.h: New file. * sysdeps/i386/i486/atomicity.h: Removed. * sysdeps/x86_64/atomicity.h: Removed. * sysdeps/s390/s390-32/atomicity.h: Removed. * sysdeps/s390/s390-64/atomicity.h: Removed. * sysdeps/ia64/atomicity.h: Removed. * sysdeps/powerpc/powerpc32/atomicity.h: Removed. * sysdeps/powerpc/powerpc64/atomicity.h: Removed. * elf/dl-profile.c: Use atomic.h instead of atomicity.h. Adjust use of macros from atomicity.h to new names and semantics. * gmon_mcount.c: Likewise. * malloc/set-freeres.c: Likewise. * nscd/cache.c: Likewise. * stdlib/cxa_finalize.c: Likewise. * sysdeps/unix/sysv/linux/getsysstats.c: Likewise. * sysdeps/mips/ieee754.h: New file, suitable to replace both * stdlib/strtod.c (INTERNAL): While eating trailing zeros handle --- sysdeps/generic/bits/atomic.h | 31 +++ sysdeps/i386/i486/atomicity.h | 57 ----- sysdeps/i386/i486/bits/atomic.h | 348 +++++++++++++++++++++++++++++ sysdeps/ia64/atomicity.h | 48 ---- sysdeps/ia64/bits/atomic.h | 97 ++++++++ sysdeps/powerpc/bits/atomic.h | 116 ++++++++++ sysdeps/powerpc/powerpc32/atomicity.h | 98 -------- sysdeps/powerpc/powerpc64/atomicity.h | 132 ----------- sysdeps/s390/bits/atomic.h | 78 +++++++ sysdeps/s390/s390-32/atomicity.h | 76 ------- sysdeps/s390/s390-64/atomicity.h | 76 ------- sysdeps/sh/bits/atomic.h | 405 ++++++++++++++++++++++++++++++++++ sysdeps/unix/sysv/linux/getsysstats.c | 7 +- sysdeps/x86_64/atomicity.h | 57 ----- sysdeps/x86_64/bits/atomic.h | 294 ++++++++++++++++++++++++ 15 files changed, 1372 insertions(+), 548 deletions(-) create mode 100644 sysdeps/generic/bits/atomic.h delete mode 100644 sysdeps/i386/i486/atomicity.h create mode 100644 sysdeps/i386/i486/bits/atomic.h delete mode 100644 sysdeps/ia64/atomicity.h create mode 100644 sysdeps/ia64/bits/atomic.h create mode 100644 sysdeps/powerpc/bits/atomic.h delete mode 100644 sysdeps/powerpc/powerpc32/atomicity.h delete mode 100644 sysdeps/powerpc/powerpc64/atomicity.h create mode 100644 sysdeps/s390/bits/atomic.h delete mode 100644 sysdeps/s390/s390-32/atomicity.h delete mode 100644 sysdeps/s390/s390-64/atomicity.h create mode 100644 sysdeps/sh/bits/atomic.h delete mode 100644 sysdeps/x86_64/atomicity.h create mode 100644 sysdeps/x86_64/bits/atomic.h (limited to 'sysdeps') diff --git a/sysdeps/generic/bits/atomic.h b/sysdeps/generic/bits/atomic.h new file mode 100644 index 0000000000..7595b407ca --- /dev/null +++ b/sysdeps/generic/bits/atomic.h @@ -0,0 +1,31 @@ +/* Copyright (C) 2003 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Ulrich Drepper , 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, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +#ifndef _BITS_ATOMIC_H +#define _BITS_ATOMIC_H 1 + +/* We have by default no support for atomic operations. So define + them non-atomic. If this is a problem somebody will have to come + up with real definitions. */ + +/* The only basic operation needed is compare and exchange. */ +#define arch_compare_and_exchange_acq(mem, newval, oldval) \ + ({ *(mem) == (oldval) ? 1 : (*(mem) = (newval), 0); }) + +#endif /* bits/atomic.h */ diff --git a/sysdeps/i386/i486/atomicity.h b/sysdeps/i386/i486/atomicity.h deleted file mode 100644 index df2fb81847..0000000000 --- a/sysdeps/i386/i486/atomicity.h +++ /dev/null @@ -1,57 +0,0 @@ -/* Low-level functions for atomic operations. ix86 version, x >= 4. - Copyright (C) 1997, 2000, 2001 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - 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, write to the Free - Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA - 02111-1307 USA. */ - -#ifndef _ATOMICITY_H -#define _ATOMICITY_H 1 - -#include - - -static inline uint32_t -__attribute__ ((unused)) -exchange_and_add (volatile uint32_t *mem, uint32_t val) -{ - register uint32_t result; - __asm__ __volatile__ ("lock; xaddl %0,%1" - : "=r" (result), "=m" (*mem) : "0" (val), "1" (*mem)); - return result; -} - -static inline void -__attribute__ ((unused)) -atomic_add (volatile uint32_t *mem, int val) -{ - __asm__ __volatile__ ("lock; addl %1,%0" - : "=m" (*mem) : "ir" (val), "0" (*mem)); -} - -static inline char -__attribute__ ((unused)) -compare_and_swap (volatile long int *p, long int oldval, long int newval) -{ - char ret; - long int readval; - - __asm__ __volatile__ ("lock; cmpxchgl %3, %1; sete %0" - : "=q" (ret), "=m" (*p), "=a" (readval) - : "r" (newval), "1" (*p), "a" (oldval)); - return ret; -} - -#endif /* atomicity.h */ diff --git a/sysdeps/i386/i486/bits/atomic.h b/sysdeps/i386/i486/bits/atomic.h new file mode 100644 index 0000000000..80a49872e1 --- /dev/null +++ b/sysdeps/i386/i486/bits/atomic.h @@ -0,0 +1,348 @@ +/* Copyright (C) 2002, 2003 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Ulrich Drepper , 2002. + + 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, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +#include + + +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; + + +#ifndef LOCK +# ifdef UP +# define LOCK /* nothing */ +# else +# define LOCK "lock;" +# endif +#endif + + +#define __arch_compare_and_exchange_8_acq(mem, newval, oldval) \ + ({ unsigned char ret; \ + __asm __volatile (LOCK "cmpxchgb %b2, %1; setne %0" \ + : "=a" (ret), "=m" (*mem) \ + : "q" (newval), "1" (*mem), "0" (oldval)); \ + ret; }) + +#define __arch_compare_and_exchange_16_acq(mem, newval, oldval) \ + ({ unsigned char ret; \ + __asm __volatile (LOCK "cmpxchgw %w2, %1; setne %0" \ + : "=a" (ret), "=m" (*mem) \ + : "r" (newval), "1" (*mem), "0" (oldval)); \ + ret; }) + +#define __arch_compare_and_exchange_32_acq(mem, newval, oldval) \ + ({ unsigned char ret; \ + __asm __volatile (LOCK "cmpxchgl %2, %1; setne %0" \ + : "=a" (ret), "=m" (*mem) \ + : "r" (newval), "1" (*mem), "0" (oldval)); \ + ret; }) + +/* XXX We do not really need 64-bit compare-and-exchange. At least + not in the moment. Using it would mean causing portability + problems since not many other 32-bit architectures have support for + such an operation. So don't define any code for now. If it is + really going to be used the code below can be used on Intel Pentium + and later, but NOT on i486. */ +#if 1 +# define __arch_compare_and_exchange_64_acq(mem, newval, oldval) \ + (abort (), 0) +#else +# ifdef __PIC__ +# define __arch_compare_and_exchange_64_acq(mem, newval, oldval) \ + ({ unsigned char ret; \ + int ignore; \ + __asm __volatile ("xchgl %3, %%ebx\n\t" \ + LOCK "cmpxchg8b %2, %1\n\t" \ + "setne %0\n\t" \ + "xchgl %3, %%ebx" \ + : "=a" (ret), "=m" (*mem), "=d" (ignore) \ + : "DS" (((unsigned long long int) (newval)) \ + & 0xffffffff), \ + "c" (((unsigned long long int) (newval)) >> 32), \ + "1" (*mem), "0" (((unsigned long long int) (oldval)) \ + & 0xffffffff), \ + "2" (((unsigned long long int) (oldval)) >> 32)); \ + ret; }) +# else +# define __arch_compare_and_exchange_64_acq(mem, newval, oldval) \ + ({ unsigned char ret; \ + int ignore; \ + __asm __volatile (LOCK "cmpxchg8b %2, %1; setne %0" \ + : "=a" (ret), "=m" (*mem), "=d" (ignore) \ + : "b" (((unsigned long long int) (newval)) \ + & 0xffffffff), \ + "c" (((unsigned long long int) (newval)) >> 32), \ + "1" (*mem), "0" (((unsigned long long int) (oldval)) \ + & 0xffffffff), \ + "2" (((unsigned long long int) (oldval)) >> 32)); \ + ret; }) +# endif +#endif + + +#define atomic_exchange_and_add(mem, value) \ + ({ __typeof (*mem) result; \ + __typeof (value) addval = (value); \ + if (sizeof (*mem) == 1) \ + { \ + __asm __volatile (LOCK "xaddb %b0, %1" \ + : "=r" (result), "=m" (*mem) \ + : "0" (addval), "1" (*mem)); \ + result += addval; \ + } \ + else if (sizeof (*mem) == 2) \ + { \ + __asm __volatile (LOCK "xaddw %w0, %1" \ + : "=r" (result), "=m" (*mem) \ + : "0" (addval), "1" (*mem)); \ + result += addval; \ + } \ + else if (sizeof (*mem) == 4) \ + { \ + __asm __volatile (LOCK "xaddl %0, %1" \ + : "=r" (result), "=m" (*mem) \ + : "0" (addval), "1" (*mem)); \ + result += addval; \ + } \ + else \ + { \ + __typeof (*mem) oldval; \ + __typeof (mem) memp = (mem); \ + do \ + result = (oldval = *memp) + addval; \ + while (__arch_compare_and_exchange_64_acq (memp, result, oldval)); \ + } \ + result; }) + + +#define atomic_add(mem, value) \ + (void) ({ if (__builtin_constant_p (value) && (value) == 1) \ + atomic_increment (mem); \ + else if (__builtin_constant_p (value) && (value) == 1) \ + atomic_decrement (mem); \ + else if (sizeof (*mem) == 1) \ + __asm __volatile (LOCK "addb %b1, %0" \ + : "=m" (*mem) \ + : "ir" (value), "0" (*mem)); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile (LOCK "addw %w1, %0" \ + : "=m" (*mem) \ + : "ir" (value), "0" (*mem)); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile (LOCK "addl %1, %0" \ + : "=m" (*mem) \ + : "ir" (value), "0" (*mem)); \ + else \ + { \ + __typeof (value) addval = (value); \ + __typeof (*mem) oldval; \ + __typeof (mem) memp = (mem); \ + do \ + oldval = *memp; \ + while (__arch_compare_and_exchange_64_acq (memp, \ + oldval + addval, \ + oldval)); \ + } \ + }) + + +#define atomic_add_negative(mem, value) \ + ({ unsigned char __result; \ + if (sizeof (*mem) == 1) \ + __asm __volatile (LOCK "addb %b2, %0; sets %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "iq" (value), "0" (*mem)); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile (LOCK "addw %w2, %0; sets %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "ir" (value), "0" (*mem)); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile (LOCK "addl %2, %0; sets %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "ir" (value), "0" (*mem)); \ + else \ + abort (); \ + __result; }) + + +#define atomic_add_zero(mem, value) \ + ({ unsigned char __result; \ + if (sizeof (*mem) == 1) \ + __asm __volatile (LOCK "addb %b2, %0; setz %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "ir" (value), "0" (*mem)); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile (LOCK "addw %w2, %0; setz %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "ir" (value), "0" (*mem)); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile (LOCK "addl %2, %0; setz %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "ir" (value), "0" (*mem)); \ + else \ + abort (); \ + __result; }) + + +#define atomic_increment(mem) \ + (void) ({ if (sizeof (*mem) == 1) \ + __asm __volatile (LOCK "incb %b0" \ + : "=m" (*mem) \ + : "0" (*mem)); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile (LOCK "incw %w0" \ + : "=m" (*mem) \ + : "0" (*mem)); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile (LOCK "incl %0" \ + : "=m" (*mem) \ + : "0" (*mem)); \ + else \ + { \ + __typeof (*mem) oldval; \ + __typeof (mem) memp = (mem); \ + do \ + oldval = *memp; \ + while (__arch_compare_and_exchange_64_acq (memp, oldval + 1, \ + oldval)); \ + } \ + }) + + +#define atomic_increment_and_test(mem) \ + ({ unsigned char __result; \ + if (sizeof (*mem) == 1) \ + __asm __volatile (LOCK "incb %0; sete %b1" \ + : "=m" (*mem), "=qm" (__result) \ + : "0" (*mem)); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile (LOCK "incw %0; sete %w1" \ + : "=m" (*mem), "=qm" (__result) \ + : "0" (*mem)); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile (LOCK "incl %0; sete %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "0" (*mem)); \ + else \ + abort (); \ + __result; }) + + +#define atomic_decrement(mem) \ + (void) ({ if (sizeof (*mem) == 1) \ + __asm __volatile (LOCK "decb %b0" \ + : "=m" (*mem) \ + : "0" (*mem)); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile (LOCK "decw %w0" \ + : "=m" (*mem) \ + : "0" (*mem)); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile (LOCK "decl %0" \ + : "=m" (*mem) \ + : "0" (*mem)); \ + else \ + { \ + __typeof (*mem) oldval; \ + __typeof (mem) memp = (mem); \ + do \ + oldval = *memp; \ + while (__arch_compare_and_exchange_64_acq (memp, oldval - 1, \ + oldval)); \ + } \ + }) + + +#define atomic_decrement_and_test(mem) \ + ({ unsigned char __result; \ + if (sizeof (*mem) == 1) \ + __asm __volatile (LOCK "decb %b0; sete %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "0" (*mem)); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile (LOCK "decw %w0; sete %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "0" (*mem)); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile (LOCK "decl %0; sete %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "0" (*mem)); \ + else \ + abort (); \ + __result; }) + + +#define atomic_bit_set(mem, bit) \ + (void) ({ if (sizeof (*mem) == 1) \ + __asm __volatile (LOCK "orb %b2, %0" \ + : "=m" (*mem) \ + : "0" (*mem), "i" (1 << (bit))); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile (LOCK "orw %w2, %0" \ + : "=m" (*mem) \ + : "0" (*mem), "i" (1 << (bit))); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile (LOCK "orl %2, %0" \ + : "=m" (*mem) \ + : "0" (*mem), "i" (1 << (bit))); \ + else \ + abort (); \ + }) + + +#define atomic_bit_test_set(mem, bit) \ + ({ unsigned char __result; \ + if (sizeof (*mem) == 1) \ + __asm __volatile (LOCK "btsb %3, %1; setc %0" \ + : "=q" (__result), "=m" (*mem) \ + : "1" (*mem), "i" (bit)); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile (LOCK "btsw %3, %1; setc %0" \ + : "=q" (__result), "=m" (*mem) \ + : "1" (*mem), "i" (bit)); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile (LOCK "btsl %3, %1; setc %0" \ + : "=q" (__result), "=m" (*mem) \ + : "1" (*mem), "i" (bit)); \ + else \ + abort (); \ + __result; }) diff --git a/sysdeps/ia64/atomicity.h b/sysdeps/ia64/atomicity.h deleted file mode 100644 index 615befd580..0000000000 --- a/sysdeps/ia64/atomicity.h +++ /dev/null @@ -1,48 +0,0 @@ -/* Low-level functions for atomic operations. IA-64 version. - Copyright (C) 2001 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - 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, write to the Free - Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA - 02111-1307 USA. */ - -#ifndef _ATOMICITY_H -#define _ATOMICITY_H 1 - -#include -#include - - -static inline uint32_t -__attribute__ ((unused)) -exchange_and_add (volatile uint32_t *mem, uint32_t val) -{ - return __sync_fetch_and_add (mem, val); -} - -static inline void -__attribute__ ((unused)) -atomic_add (volatile uint32_t *mem, int val) -{ - __sync_fetch_and_add (mem, val); -} - -static inline int -__attribute__ ((unused)) -compare_and_swap (volatile long int *p, long int oldval, long int newval) -{ - return __sync_bool_compare_and_swap (p, oldval, newval); -} - -#endif /* atomicity.h */ diff --git a/sysdeps/ia64/bits/atomic.h b/sysdeps/ia64/bits/atomic.h new file mode 100644 index 0000000000..fab23076cd --- /dev/null +++ b/sysdeps/ia64/bits/atomic.h @@ -0,0 +1,97 @@ +/* Copyright (C) 2003 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + 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, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +#include +#include + +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; + + +#define __arch_compare_and_exchange_8_acq(mem, newval, oldval) \ + (abort (), 0) + +#define __arch_compare_and_exchange_16_acq(mem, newval, oldval) \ + (abort (), 0) + +#define __arch_compare_and_exchange_32_acq(mem, newval, oldval) \ + (!__sync_bool_compare_and_swap_si ((int *) (mem), (int) (long) (oldval), \ + (int) (long) (newval))) + +# define __arch_compare_and_exchange_64_acq(mem, newval, oldval) \ + (!__sync_bool_compare_and_swap_di ((long *) (mem), (long) (oldval), \ + (long) (newval))) + +#define __arch_compare_and_exchange_32_val_acq(mem, newval, oldval) \ + __sync_val_compare_and_swap_si ((int *) (mem), (int) (long) (oldval), \ + (int) (long) (newval)) + +# define __arch_compare_and_exchange_64_val_acq(mem, newval, oldval) \ + __sync_val_compare_and_swap_di ((long *) (mem), (long) (oldval), \ + (long) (newval)) + +# define atomic_exchange_and_add(mem, value) \ + ({ \ + __typeof (*mem) __oldval, __val; \ + __typeof (mem) __memp = (mem); \ + __typeof (*mem) __value = (value); \ + \ + __val = *__memp; \ + if (sizeof (*mem) == 4) \ + do \ + { \ + __oldval = __val; \ + __val = __arch_compare_and_exchange_32_val_acq (__memp, \ + __oldval + __value, \ + __oldval); \ + } \ + while (__builtin_expect (__val != __oldval, 0)); \ + else if (sizeof (*mem) == 8) \ + do \ + { \ + __oldval = __val; \ + __val = __arch_compare_and_exchange_64_val_acq (__memp, \ + __oldval + __value, \ + __oldval); \ + } \ + while (__builtin_expect (__val != __oldval, 0)); \ + else \ + abort (); \ + __oldval + __value; }) diff --git a/sysdeps/powerpc/bits/atomic.h b/sysdeps/powerpc/bits/atomic.h new file mode 100644 index 0000000000..af6156389f --- /dev/null +++ b/sysdeps/powerpc/bits/atomic.h @@ -0,0 +1,116 @@ +/* Atomic operations. PowerPC version. + Copyright (C) 2003 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Paul Mackerras , 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, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +#include + +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; + + +#define __arch_compare_and_exchange_8_acq(mem, newval, oldval) \ + (abort (), 0) + +#define __arch_compare_and_exchange_16_acq(mem, newval, oldval) \ + (abort (), 0) + +#ifdef UP +#define __ARCH_ACQ_INSTR "" +#define __ARCH_REL_INSTR "" +#else +#define __ARCH_ACQ_INSTR "isync" +#define __ARCH_REL_INSTR "sync" +#endif + +/* + * XXX At present these have both acquire and release semantics. + * Ultimately we should do separate _acq and _rel versions. + */ + +/* + * XXX this may not work properly on 64-bit if the register + * containing oldval has the high half non-zero for some reason. + */ +#define __arch_compare_and_exchange_32_acq(mem, newval, oldval) \ +({ \ + unsigned int __tmp; \ + __asm __volatile (__ARCH_REL_INSTR "\n" \ + "1: lwarx %0,0,%1\n" \ + " subf. %0,%2,%0\n" \ + " bne 2f\n" \ + " stwcx. %3,0,%1\n" \ + " bne- 1b\n" \ + "2: " __ARCH_ACQ_INSTR \ + : "=&r" (__tmp) \ + : "r" (mem), "r" (oldval), "r" (newval) \ + : "cr0", "memory"); \ + __tmp != 0; \ +}) + +#ifdef __powerpc64__ +#define __arch_compare_and_exchange_64_acq(mem, newval, oldval) \ +({ \ + unsigned long __tmp; \ + __asm __volatile (__ARCH_REL_INSTR "\n" \ + "1: ldarx %0,0,%1\n" \ + " subf. %0,%2,%0\n" \ + " bne 2f\n" \ + " stdcx. %3,0,%1\n" \ + " bne- 1b\n" \ + "2: " __ARCH_ACQ_INSTR \ + : "=&r" (__tmp) \ + : "r" (mem), "r" (oldval), "r" (newval) \ + : "cr0", "memory"); \ + __tmp != 0; \ +}) + +#else /* powerpc32 */ +#define __arch_compare_and_exchange_64_acq(mem, newval, oldval) \ + (abort (), 0) +#endif + +#define atomic_full_barrier() __asm ("sync" ::: "memory") +#ifdef __powerpc64__ +#define atomic_read_barrier() __asm ("lwsync" ::: "memory") +#else +#define atomic_read_barrier() __asm ("sync" ::: "memory") +#endif +#define atomic_write_barrier() __asm ("eieio" ::: "memory") diff --git a/sysdeps/powerpc/powerpc32/atomicity.h b/sysdeps/powerpc/powerpc32/atomicity.h deleted file mode 100644 index 253bd32673..0000000000 --- a/sysdeps/powerpc/powerpc32/atomicity.h +++ /dev/null @@ -1,98 +0,0 @@ -/* Low-level functions for atomic operations. PowerPC version. - Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - 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, write to the Free - Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA - 02111-1307 USA. */ - -#ifndef _ATOMICITY_H -#define _ATOMICITY_H 1 - -#include - -static inline int -__attribute__ ((unused)) -exchange_and_add (volatile uint32_t *mem, int val) -{ - int tmp, result; - __asm__ ("\n\ -0: lwarx %0,0,%2 \n\ - add%I3 %1,%0,%3 \n\ - stwcx. %1,0,%2 \n\ - bne- 0b \n\ -" : "=&b"(result), "=&r"(tmp) : "r" (mem), "Ir"(val) : "cr0", "memory"); - return result; -} - -static inline void -__attribute__ ((unused)) -atomic_add (volatile uint32_t *mem, int val) -{ - int tmp; - __asm__ ("\n\ -0: lwarx %0,0,%1 \n\ - add%I2 %0,%0,%2 \n\ - stwcx. %0,0,%1 \n\ - bne- 0b \n\ -" : "=&b"(tmp) : "r" (mem), "Ir"(val) : "cr0", "memory"); -} - -static inline int -__attribute__ ((unused)) -compare_and_swap (volatile long int *p, long int oldval, long int newval) -{ - int result; - __asm__ ("\n\ -0: lwarx %0,0,%1 \n\ - sub%I2c. %0,%0,%2 \n\ - cntlzw %0,%0 \n\ - bne- 1f \n\ - stwcx. %3,0,%1 \n\ - bne- 0b \n\ -1: \n\ -" : "=&b"(result) : "r"(p), "Ir"(oldval), "r"(newval) : "cr0", "memory"); - return result >> 5; -} - -static inline long int -__attribute__ ((unused)) -always_swap (volatile long int *p, long int newval) -{ - long int result; - __asm__ ("\n\ -0: lwarx %0,0,%1 \n\ - stwcx. %2,0,%1 \n\ - bne- 0b \n\ -" : "=&r"(result) : "r"(p), "r"(newval) : "cr0", "memory"); - return result; -} - -static inline int -__attribute__ ((unused)) -test_and_set (volatile long int *p, long int newval) -{ - int result; - __asm__ ("\n\ -0: lwarx %0,0,%1 \n\ - cmpwi %0,0 \n\ - bne- 1f \n\ - stwcx. %2,0,%1 \n\ - bne- 0b \n\ -1: \n\ -" : "=&r"(result) : "r"(p), "r"(newval) : "cr0", "memory"); - return result; -} - -#endif /* atomicity.h */ diff --git a/sysdeps/powerpc/powerpc64/atomicity.h b/sysdeps/powerpc/powerpc64/atomicity.h deleted file mode 100644 index b9d0de0ac5..0000000000 --- a/sysdeps/powerpc/powerpc64/atomicity.h +++ /dev/null @@ -1,132 +0,0 @@ -/* Low-level functions for atomic operations. PowerPC64 version. - Copyright (C) 1997, 1998, 1999, 2000, 2002 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - The GNU C Library is free software; you can redistribute it and/or - modify it under the terms of the GNU Library General Public License as - published by the Free Software Foundation; either version 2 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 - Library General Public License for more details. - - You should have received a copy of the GNU Library General Public - License along with the GNU C Library; see the file COPYING.LIB. If not, - write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ - -#ifndef _ATOMICITY_H -#define _ATOMICITY_H 1 - -#include - -#if BROKEN_PPC_ASM_CR0 -# define __ATOMICITY_INLINE /* nothing */ -#else -# define __ATOMICITY_INLINE inline -#endif - -static __ATOMICITY_INLINE int -__attribute__ ((unused)) -exchange_and_add (volatile uint32_t *mem, int val) -{ - int tmp, result; - __asm__ ("\n\ -0: lwarx %0,0,%2 \n\ - add%I3 %1,%0,%3 \n\ - stwcx. %1,0,%2 \n\ - bne- 0b \n\ -" : "=&b"(result), "=&r"(tmp) : "r" (mem), "Ir"(val) : "cr0", "memory"); - return result; -} - -static __ATOMICITY_INLINE void -__attribute__ ((unused)) -atomic_add_long (volatile long *mem, int val) -{ - int tmp; - __asm__ ("\n\ -0: ldarx %0,0,%1 \n\ - add%I2 %0,%0,%2 \n\ - stdcx. %0,0,%1 \n\ - bne- 0b \n\ -" : "=&b"(tmp) : "r" (mem), "Ir"(val) : "cr0", "memory"); -} - - -static __ATOMICITY_INLINE int -__attribute__ ((unused)) -exchange_and_add_long (volatile long *mem, int val) -{ - int tmp, result; - __asm__ ("\n\ -0: ldarx %0,0,%2 \n\ - add%I3 %1,%0,%3 \n\ - stdcx. %1,0,%2 \n\ - bne- 0b \n\ -" : "=&b"(result), "=&r"(tmp) : "r" (mem), "Ir"(val) : "cr0", "memory"); - return result; -} - -static __ATOMICITY_INLINE void -__attribute__ ((unused)) -atomic_add (volatile uint32_t *mem, int val) -{ - int tmp; - __asm__ ("\n\ -0: lwarx %0,0,%1 \n\ - add%I2 %0,%0,%2 \n\ - stwcx. %0,0,%1 \n\ - bne- 0b \n\ -" : "=&b"(tmp) : "r" (mem), "Ir"(val) : "cr0", "memory"); -} - -static __ATOMICITY_INLINE int -__attribute__ ((unused)) -compare_and_swap (volatile long int *p, long int oldval, long int newval) -{ - int result; - __asm__ ("\n\ -0: ldarx %0,0,%1 \n\ - sub%I2c. %0,%0,%2 \n\ - cntlzw %0,%0 \n\ - bne- 1f \n\ - stdcx. %3,0,%1 \n\ - bne- 0b \n\ -1: \n\ -" : "=&b"(result) : "r"(p), "Ir"(oldval), "r"(newval) : "cr0", "memory"); - return result >> 5; -} - -static __ATOMICITY_INLINE long int -__attribute__ ((unused)) -always_swap (volatile long int *p, long int newval) -{ - long int result; - __asm__ ("\n\ -0: ldarx %0,0,%1 \n\ - stdcx. %2,0,%1 \n\ - bne- 0b \n\ -" : "=&r"(result) : "r"(p), "r"(newval) : "cr0", "memory"); - return result; -} - -static __ATOMICITY_INLINE int -__attribute__ ((unused)) -test_and_set (volatile long int *p, long int newval) -{ - int result; - __asm__ ("\n\ -0: ldarx %0,0,%1 \n\ - cmpdi %0,0 \n\ - bne- 1f \n\ - stdcx. %2,0,%1 \n\ - bne- 0b \n\ -1: \n\ -" : "=&r"(result) : "r"(p), "r"(newval) : "cr0", "memory"); - return result; -} - -#endif /* atomicity.h */ diff --git a/sysdeps/s390/bits/atomic.h b/sysdeps/s390/bits/atomic.h new file mode 100644 index 0000000000..375ae0d5e7 --- /dev/null +++ b/sysdeps/s390/bits/atomic.h @@ -0,0 +1,78 @@ +/* Copyright (C) 2003 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Martin Schwidefsky , 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, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +#include + +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; + + +#define __arch_compare_and_exchange_8_acq(mem, newval, oldval) \ + (abort (), 0) + +#define __arch_compare_and_exchange_16_acq(mem, newval, oldval) \ + (abort (), 0) + +#define __arch_compare_and_exchange_32_acq(mem, newval, oldval) \ + ({ unsigned int *__mem = (unsigned int *) (mem); \ + unsigned int __old = (unsigned int) (oldval); \ + unsigned int __cmp = __old; \ + __asm __volatile ("cs %0,%2,%1" \ + : "+d" (__old), "=Q" (*__mem) \ + : "d" (newval), "m" (*__mem) : "cc" ); \ + __cmp != __old; }) + +#ifdef __s390x__ +# define __arch_compare_and_exchange_64_acq(mem, newval, oldval) \ + ({ unsigned long int *__mem = (unsigned long int *) (mem); \ + unsigned long int __old = (unsigned long int) (oldval); \ + unsigned long int __cmp = __old; \ + __asm __volatile ("csg %0,%2,%1" \ + : "+d" (__old), "=Q" (*__mem) \ + : "d" (newval), "m" (*__mem) : "cc" ); \ + __cmp != __old; }) +#else +/* For 31 bit we do not really need 64-bit compare-and-exchange. We can + implement them by use of the csd instruction. The straightforward + implementation causes warnings so we skip the definition for now. */ +# define __arch_compare_and_exchange_64_acq(mem, newval, oldval) \ + (abort (), 0) +#endif diff --git a/sysdeps/s390/s390-32/atomicity.h b/sysdeps/s390/s390-32/atomicity.h deleted file mode 100644 index 32a7c0f06b..0000000000 --- a/sysdeps/s390/s390-32/atomicity.h +++ /dev/null @@ -1,76 +0,0 @@ -/* Low-level functions for atomic operations. S390 version. - Copyright (C) 2000, 2001 Free Software Foundation, Inc. - Contributed by Martin Schwidefsky (schwidefsky@de.ibm.com). - This file is part of the GNU C Library. - - 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, write to the Free - Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA - 02111-1307 USA. */ - -#ifndef _ATOMICITY_H -#define _ATOMICITY_H 1 - -#include - -static inline int -__attribute__ ((unused)) -exchange_and_add (volatile uint32_t *mem, int val) -{ - int result; - __asm__ __volatile__( - " L %0,%2\n" - " LA 2,%1\n" - "0: LR 0,%0\n" - " AR 0,%3\n" - " CS %0,0,0(2)\n" - " JL 0b" - : "=&d" (result), "=m" (*mem) - : "1" (*mem), "d" (val) : "0", "1", "2" ); - return result; -} - -static inline void -__attribute__ ((unused)) -atomic_add (volatile uint32_t *mem, int val) -{ - __asm__ __volatile__( - " LA 2,%0\n" - "0: L 0,%1\n" - " LR 1,0\n" - " AR 1,%2\n" - " CS 0,1,0(2)\n" - " JL 0b" - : "=m" (*mem) : "0" (*mem), "d" (val) : "0", "1", "2" ); -} - -static inline int -__attribute__ ((unused)) -compare_and_swap (volatile long int *p, long int oldval, long int newval) -{ - int retval; - - __asm__ __volatile__( - " la 1,%1\n" - " lr 0,%2\n" - " cs 0,%3,0(1)\n" - " ipm %0\n" - " srl %0,28\n" - "0:" - : "=&r" (retval), "+m" (*p) - : "d" (oldval) , "d" (newval) - : "memory", "0", "1", "cc"); - return !retval; -} - -#endif /* atomicity.h */ diff --git a/sysdeps/s390/s390-64/atomicity.h b/sysdeps/s390/s390-64/atomicity.h deleted file mode 100644 index 11a5f7fa53..0000000000 --- a/sysdeps/s390/s390-64/atomicity.h +++ /dev/null @@ -1,76 +0,0 @@ -/* Low-level functions for atomic operations. 64 bit S/390 version. - Copyright (C) 2001 Free Software Foundation, Inc. - Contributed by Martin Schwidefsky (schwidefsky@de.ibm.com). - This file is part of the GNU C Library. - - 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, write to the Free - Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA - 02111-1307 USA. */ - -#ifndef _ATOMICITY_H -#define _ATOMICITY_H 1 - -#include - -static inline int -__attribute__ ((unused)) -exchange_and_add (volatile uint32_t *mem, int val) -{ - int result; - __asm__ __volatile__( - " L %0,%2\n" - " LA 2,%1\n" - "0: LR 0,%0\n" - " AR 0,%3\n" - " CS %0,0,0(2)\n" - " JL 0b" - : "=&d" (result), "=m" (*mem) - : "1" (*mem), "d" (val) : "0", "1", "2" ); - return result; -} - -static inline void -__attribute__ ((unused)) -atomic_add (volatile uint32_t *mem, int val) -{ - __asm__ __volatile__( - " LA 2,%0\n" - "0: L 0,%1\n" - " LR 1,0\n" - " AR 1,%2\n" - " CS 0,1,0(2)\n" - " JL 0b" - : "=m" (*mem) : "0" (*mem), "d" (val) : "0", "1", "2" ); -} - -static inline int -__attribute__ ((unused)) -compare_and_swap (volatile long int *p, long int oldval, long int newval) -{ - int retval; - - __asm__ __volatile__( - " la 1,%1\n" - " lgr 0,%2\n" - " csg 0,%3,0(1)\n" - " ipm %0\n" - " srl %0,28\n" - "0:" - : "=&r" (retval), "+m" (*p) - : "d" (oldval) , "d" (newval) - : "memory", "0", "1", "cc"); - return !retval; -} - -#endif /* atomicity.h */ diff --git a/sysdeps/sh/bits/atomic.h b/sysdeps/sh/bits/atomic.h new file mode 100644 index 0000000000..de176ca2c5 --- /dev/null +++ b/sysdeps/sh/bits/atomic.h @@ -0,0 +1,405 @@ +/* Copyright (C) 2003 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + 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, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +#include + + +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; + + +#define __arch_compare_and_exchange_8_acq(mem, newval, oldval) \ + ({ unsigned char __result; \ + __asm __volatile ("\ + .align 2\n\ + mova 1f,r0\n\ + nop\n\ + mov r15,r1\n\ + mov #-8,r15\n\ + 0: mov.b @%1,r2\n\ + cmp/eq r2,%3\n\ + bf 1f\n\ + mov.b %2,@%1\n\ + 1: mov r1,r15\n\ + mov #-1,%0\n\ + negc %0,%0"\ + : "=r" (__result) : "r" (mem), "r" (newval), "r" (oldval) \ + : "r0", "r1", "r2", "t", "memory"); \ + __result; }) + +#define __arch_compare_and_exchange_16_acq(mem, newval, oldval) \ + ({ unsigned char __result; \ + __asm __volatile ("\ + .align 2\n\ + mova 1f,r0\n\ + nop\n\ + mov r15,r1\n\ + mov #-8,r15\n\ + 0: mov.w @%1,r2\n\ + cmp/eq r2,%3\n\ + bf 1f\n\ + mov.w %2,@%1\n\ + 1: mov r1,r15\n\ + mov #-1,%0\n\ + negc %0,%0"\ + : "=r" (__result) : "r" (mem), "r" (newval), "r" (oldval) \ + : "r0", "r1", "r2", "t", "memory"); \ + __result; }) + +#define __arch_compare_and_exchange_32_acq(mem, newval, oldval) \ + ({ unsigned char __result; \ + __asm __volatile ("\ + .align 2\n\ + mova 1f,r0\n\ + nop\n\ + mov r15,r1\n\ + mov #-8,r15\n\ + 0: mov.l @%1,r2\n\ + cmp/eq r2,%3\n\ + bf 1f\n\ + mov.l %2,@%1\n\ + 1: mov r1,r15\n\ + mov #-1,%0\n\ + negc %0,%0"\ + : "=r" (__result) : "r" (mem), "r" (newval), "r" (oldval) \ + : "r0", "r1", "r2", "t", "memory"); \ + __result; }) + +/* XXX We do not really need 64-bit compare-and-exchange. At least + not in the moment. Using it would mean causing portability + problems since not many other 32-bit architectures have support for + such an operation. So don't define any code for now. */ + +# define __arch_compare_and_exchange_64_acq(mem, newval, oldval) \ + (abort (), 0) + +#define atomic_exchange_and_add(mem, value) \ + ({ __typeof (*mem) __result; \ + if (sizeof (*mem) == 1) \ + __asm __volatile ("\ + .align 2\n\ + mova 1f,r0\n\ + mov r15,r1\n\ + mov #-6,r15\n\ + 0: mov.b @%2,%0\n\ + add %0,%1\n\ + mov.b %1,@%2\n\ + 1: mov r1,r15"\ + : "=&r" (__result), "=&r" (value) : "r" (mem), "1" (value) \ + : "r0", "r1", "memory"); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile ("\ + .align 2\n\ + mova 1f,r0\n\ + mov r15,r1\n\ + mov #-6,r15\n\ + 0: mov.w @%2,%0\n\ + add %0,%1\n\ + mov.w %1,@%2\n\ + 1: mov r1,r15"\ + : "=&r" (__result), "=&r" (value) : "r" (mem), "1" (value) \ + : "r0", "r1", "memory"); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile ("\ + .align 2\n\ + mova 1f,r0\n\ + mov r15,r1\n\ + mov #-6,r15\n\ + 0: mov.l @%2,%0\n\ + add %0,%1\n\ + mov.l %1,@%2\n\ + 1: mov r1,r15"\ + : "=&r" (__result), "=&r" (value) : "r" (mem), "1" (value) \ + : "r0", "r1", "memory"); \ + else \ + { \ + __typeof (value) addval = (value); \ + __typeof (*mem) oldval; \ + __typeof (mem) memp = (mem); \ + do \ + __result = (oldval = *memp) + addval; \ + while (!__arch_compare_and_exchange_64_acq (memp, __result, oldval));\ + (void) addval; \ + } \ + __result; }) + +#define atomic_add(mem, value) \ + (void) ({ if (sizeof (*mem) == 1) \ + __asm __volatile ("\ + .align 2\n\ + mova 1f,r0\n\ + mov r15,r1\n\ + mov #-6,r15\n\ + 0: mov.b @%1,r2\n\ + add r2,%0\n\ + mov.b %0,@%1\n\ + 1: mov r1,r15"\ + : "=&r" (value) : "r" (mem), "0" (value) \ + : "r0", "r1", "r2", "memory"); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile ("\ + .align 2\n\ + mova 1f,r0\n\ + mov r15,r1\n\ + mov #-6,r15\n\ + 0: mov.w @%1,r2\n\ + add r2,%0\n\ + mov.w %0,@%1\n\ + 1: mov r1,r15"\ + : "=&r" (value) : "r" (mem), "0" (value) \ + : "r0", "r1", "r2", "memory"); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile ("\ + .align 2\n\ + mova 1f,r0\n\ + mov r15,r1\n\ + mov #-6,r15\n\ + 0: mov.l @%1,r2\n\ + add r2,%0\n\ + mov.l %0,@%1\n\ + 1: mov r1,r15"\ + : "=&r" (value) : "r" (mem), "0" (value) \ + : "r0", "r1", "r2", "memory"); \ + else \ + { \ + __typeof (value) addval = (value); \ + __typeof (*mem) oldval; \ + __typeof (mem) memp = (mem); \ + do \ + oldval = *memp; \ + while (! __arch_compare_and_exchange_64_acq (memp, \ + oldval + addval, \ + oldval)); \ + (void) addval; \ + } \ + }) + +#define atomic_add_negative(mem, value) \ + ({ unsigned char __result; \ + if (sizeof (*mem) == 1) \ + __asm __volatile ("\ + .align 2\n\ + mova 1f,r0\n\ + mov r15,r1\n\ + mov #-6,r15\n\ + 0: mov.b @%2,r2\n\ + add r2,%1\n\ + mov.b %1,@%2\n\ + 1: mov r1,r15\n\ + shal %1\n\ + movt %0"\ + : "=r" (__result), "=&r" (value) : "r" (mem), "1" (value) \ + : "r0", "r1", "r2", "t", "memory"); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile ("\ + .align 2\n\ + mova 1f,r0\n\ + mov r15,r1\n\ + mov #-6,r15\n\ + 0: mov.w @%2,r2\n\ + add r2,%1\n\ + mov.w %1,@%2\n\ + 1: mov r1,r15\n\ + shal %1\n\ + movt %0"\ + : "=r" (__result), "=&r" (value) : "r" (mem), "1" (value) \ + : "r0", "r1", "r2", "t", "memory"); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile ("\ + .align 2\n\ + mova 1f,r0\n\ + mov r15,r1\n\ + mov #-6,r15\n\ + 0: mov.l @%2,r2\n\ + add r2,%1\n\ + mov.l %1,@%2\n\ + 1: mov r1,r15\n\ + shal %1\n\ + movt %0"\ + : "=r" (__result), "=&r" (value) : "r" (mem), "1" (value) \ + : "r0", "r1", "r2", "t", "memory"); \ + else \ + abort (); \ + __result; }) + +#define atomic_add_zero(mem, value) \ + ({ unsigned char __result; \ + if (sizeof (*mem) == 1) \ + __asm __volatile ("\ + .align 2\n\ + mova 1f,r0\n\ + mov r15,r1\n\ + mov #-6,r15\n\ + 0: mov.b @%2,r2\n\ + add r2,%1\n\ + mov.b %1,@%2\n\ + 1: mov r1,r15\n\ + tst %1,%1\n\ + movt %0"\ + : "=r" (__result), "=&r" (value) : "r" (mem), "1" (value) \ + : "r0", "r1", "r2", "t", "memory"); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile ("\ + .align 2\n\ + mova 1f,r0\n\ + mov r15,r1\n\ + mov #-6,r15\n\ + 0: mov.w @%2,r2\n\ + add r2,%1\n\ + mov.w %1,@%2\n\ + 1: mov r1,r15\n\ + tst %1,%1\n\ + movt %0"\ + : "=r" (__result), "=&r" (value) : "r" (mem), "1" (value) \ + : "r0", "r1", "r2", "t", "memory"); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile ("\ + .align 2\n\ + mova 1f,r0\n\ + mov r15,r1\n\ + mov #-6,r15\n\ + 0: mov.l @%2,r2\n\ + add r2,%1\n\ + mov.l %1,@%2\n\ + 1: mov r1,r15\n\ + tst %1,%1\n\ + movt %0"\ + : "=r" (__result), "=&r" (value) : "r" (mem), "1" (value) \ + : "r0", "r1", "r2", "t", "memory"); \ + else \ + abort (); \ + __result; }) + +#define atomic_increment_and_test(mem) atomic_add_zero((mem), 1) +#define atomic_decrement_and_test(mem) atomic_add_zero((mem), -1) + +#define atomic_bit_set(mem, bit) \ + (void) ({ unsigned int __mask = 1 << (bit); \ + if (sizeof (*mem) == 1) \ + __asm __volatile ("\ + .align 2\n\ + mova 1f,r0\n\ + mov r15,r1\n\ + mov #-6,r15\n\ + 0: mov.b @%0,r2\n\ + or %1,r2\n\ + mov.b r2,@%0\n\ + 1: mov r1,r15"\ + : : "r" (mem), "r" (__mask) \ + : "r0", "r1", "r2", "memory"); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile ("\ + .align 2\n\ + mova 1f,r0\n\ + mov r15,r1\n\ + mov #-6,r15\n\ + 0: mov.w @%0,r2\n\ + or %1,r2\n\ + mov.w r2,@%0\n\ + 1: mov r1,r15"\ + : : "r" (mem), "r" (__mask) \ + : "r0", "r1", "r2", "memory"); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile ("\ + .align 2\n\ + mova 1f,r0\n\ + mov r15,r1\n\ + mov #-6,r15\n\ + 0: mov.l @%0,r2\n\ + or %1,r2\n\ + mov.l r2,@%0\n\ + 1: mov r1,r15"\ + : : "r" (mem), "r" (__mask) \ + : "r0", "r1", "r2", "memory"); \ + else \ + abort (); \ + }) + +#define atomic_bit_test_set(mem, bit) \ + ({ unsigned int __mask = 1 << (bit); \ + unsigned int __result = __mask; \ + if (sizeof (*mem) == 1) \ + __asm __volatile ("\ + .align 2\n\ + mova 1f,r0\n\ + nop\n\ + mov r15,r1\n\ + mov #-8,r15\n\ + 0: mov.b @%2,r2\n\ + or r2,%1\n\ + and r2,%0\n\ + mov.b %1,@%2\n\ + 1: mov r1,r15"\ + : "=&r" (__result), "=&r" (__mask) \ + : "r" (mem), "0" (__result), "1" (__mask) \ + : "r0", "r1", "r2", "memory"); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile ("\ + .align 2\n\ + mova 1f,r0\n\ + nop\n\ + mov r15,r1\n\ + mov #-8,r15\n\ + 0: mov.w @%2,r2\n\ + or r2,%1\n\ + and r2,%0\n\ + mov.w %1,@%2\n\ + 1: mov r1,r15"\ + : "=&r" (__result), "=&r" (__mask) \ + : "r" (mem), "0" (__result), "1" (__mask) \ + : "r0", "r1", "r2", "memory"); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile ("\ + .align 2\n\ + mova 1f,r0\n\ + nop\n\ + mov r15,r1\n\ + mov #-8,r15\n\ + 0: mov.l @%2,r2\n\ + or r2,%1\n\ + and r2,%0\n\ + mov.l %1,@%2\n\ + 1: mov r1,r15"\ + : "=&r" (__result), "=&r" (__mask) \ + : "r" (mem), "0" (__result), "1" (__mask) \ + : "r0", "r1", "r2", "memory"); \ + else \ + abort (); \ + __result; }) diff --git a/sysdeps/unix/sysv/linux/getsysstats.c b/sysdeps/unix/sysv/linux/getsysstats.c index 55ef5b661a..c44e45ca6b 100644 --- a/sysdeps/unix/sysv/linux/getsysstats.c +++ b/sysdeps/unix/sysv/linux/getsysstats.c @@ -1,5 +1,5 @@ /* Determine various system internal values, Linux version. - Copyright (C) 1996-2001, 2002 Free Software Foundation, Inc. + Copyright (C) 1996-2001, 2002, 2003 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Ulrich Drepper , 1996. @@ -31,7 +31,7 @@ #include #include -#include +#include /* The default value for the /proc filesystem mount point. */ @@ -85,8 +85,7 @@ get_proc_path (char *buffer, size_t bufsize) /* Now store the copied value. But do it atomically. */ assert (sizeof (long int) == sizeof (void *__unbounded)); - if (compare_and_swap ((long int *) &mount_proc, (long int) 0, - (long int) copy_result) == 0) + if (atomic_compare_and_exchange_acq (&mount_proc, copy_result, NULL) == 0) /* Replacing the value failed. This means another thread was faster and we don't need the copy anymore. */ free (copy_result); diff --git a/sysdeps/x86_64/atomicity.h b/sysdeps/x86_64/atomicity.h deleted file mode 100644 index 925c9f9da5..0000000000 --- a/sysdeps/x86_64/atomicity.h +++ /dev/null @@ -1,57 +0,0 @@ -/* Low-level functions for atomic operations. x86-64 version. - Copyright (C) 1997, 2000, 2001 Free Software Foundation, Inc. - This file is part of the GNU C Library. - - 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, write to the Free - Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA - 02111-1307 USA. */ - -#ifndef _ATOMICITY_H -#define _ATOMICITY_H 1 - -#include - - -static inline uint32_t -__attribute__ ((unused)) -exchange_and_add (volatile uint32_t *mem, uint32_t val) -{ - register uint32_t result; - __asm__ __volatile__ ("lock; xaddl %0,%1" - : "=r" (result), "=m" (*mem) : "0" (val), "1" (*mem)); - return result; -} - -static inline void -__attribute__ ((unused)) -atomic_add (volatile uint32_t *mem, int val) -{ - __asm__ __volatile__ ("lock; addl %1,%0" - : "=m" (*mem) : "er" (val), "0" (*mem)); -} - -static inline char -__attribute__ ((unused)) -compare_and_swap (volatile long int *p, long int oldval, long int newval) -{ - char ret; - long int readval; - - __asm__ __volatile__ ("lock; cmpxchgq %3, %1; sete %0" - : "=q" (ret), "=m" (*p), "=a" (readval) - : "r" (newval), "1" (*p), "a" (oldval)); - return ret; -} - -#endif /* atomicity.h */ diff --git a/sysdeps/x86_64/bits/atomic.h b/sysdeps/x86_64/bits/atomic.h new file mode 100644 index 0000000000..f72f16c501 --- /dev/null +++ b/sysdeps/x86_64/bits/atomic.h @@ -0,0 +1,294 @@ +/* Copyright (C) 2002 Free Software Foundation, Inc. + This file is part of the GNU C Library. + Contributed by Ulrich Drepper , 2002. + + 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, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA. */ + +#include + + +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; + + +#ifndef LOCK +# ifdef UP +# define LOCK /* nothing */ +# else +# define LOCK "lock;" +# endif +#endif + + +#define __arch_compare_and_exchange_8_acq(mem, newval, oldval) \ + ({ unsigned char ret; \ + __asm __volatile (LOCK "cmpxchgb %b2, %1; setne %0" \ + : "=a" (ret), "=m" (*mem) \ + : "q" (newval), "1" (*mem), "0" (oldval)); \ + ret; }) + +#define __arch_compare_and_exchange_16_acq(mem, newval, oldval) \ + ({ unsigned char ret; \ + __asm __volatile (LOCK "cmpxchgw %w2, %1; setne %0" \ + : "=a" (ret), "=m" (*mem) \ + : "r" (newval), "1" (*mem), "0" (oldval)); \ + ret; }) + +#define __arch_compare_and_exchange_32_acq(mem, newval, oldval) \ + ({ unsigned char ret; \ + __asm __volatile (LOCK "cmpxchgl %2, %1; setne %0" \ + : "=a" (ret), "=m" (*mem) \ + : "r" (newval), "1" (*mem), "0" (oldval)); \ + ret; }) + +#define __arch_compare_and_exchange_64_acq(mem, newval, oldval) \ + ({ unsigned char ret; \ + __asm __volatile (LOCK "cmpxchgq %q2, %1; setne %0" \ + : "=a" (ret), "=m" (*mem) \ + : "r" (newval), "1" (*mem), "0" (oldval)); \ + ret; }) + + +#define atomic_exchange_and_add(mem, value) \ + ({ __typeof (*mem) result; \ + if (sizeof (*mem) == 1) \ + __asm __volatile (LOCK "xaddb %b0, %1" \ + : "=r" (result), "=m" (*mem) \ + : "0" (value), "1" (*mem)); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile (LOCK "xaddw %w0, %1" \ + : "=r" (result), "=m" (*mem) \ + : "0" (value), "1" (*mem)); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile (LOCK "xaddl %0, %1" \ + : "=r" (result), "=m" (*mem) \ + : "0" (value), "1" (*mem)); \ + else \ + __asm __volatile (LOCK "xaddq %q0, %1" \ + : "=r" (result), "=m" (*mem) \ + : "0" (value), "1" (*mem)); \ + result; }) + + +#define atomic_add(mem, value) \ + (void) ({ if (__builtin_constant_p (value) && (value) == 1) \ + atomic_increment (mem); \ + else if (__builtin_constant_p (value) && (value) == 1) \ + atomic_decrement (mem); \ + else if (sizeof (*mem) == 1) \ + __asm __volatile (LOCK "addb %b1, %0" \ + : "=m" (*mem) \ + : "ir" (value), "0" (*mem)); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile (LOCK "addw %w1, %0" \ + : "=m" (*mem) \ + : "ir" (value), "0" (*mem)); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile (LOCK "addl %1, %0" \ + : "=m" (*mem) \ + : "ir" (value), "0" (*mem)); \ + else \ + __asm __volatile (LOCK "addq %q1, %0" \ + : "=m" (*mem) \ + : "ir" (value), "0" (*mem)); \ + }) + + +#define atomic_add_negative(mem, value) \ + ({ unsigned char __result; \ + if (sizeof (*mem) == 1) \ + __asm __volatile (LOCK "addb %b2, %0; sets %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "ir" (value), "0" (*mem)); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile (LOCK "addw %w2, %0; sets %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "ir" (value), "0" (*mem)); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile (LOCK "addl %2, %0; sets %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "ir" (value), "0" (*mem)); \ + else \ + __asm __volatile (LOCK "addq %q2, %0; sets %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "ir" (value), "0" (*mem)); \ + __result; }) + + +#define atomic_add_zero(mem, value) \ + ({ unsigned char __result; \ + if (sizeof (*mem) == 1) \ + __asm __volatile (LOCK "addb %b2, %0; setz %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "ir" (value), "0" (*mem)); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile (LOCK "addw %w2, %0; setz %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "ir" (value), "0" (*mem)); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile (LOCK "addl %2, %0; setz %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "ir" (value), "0" (*mem)); \ + else \ + __asm __volatile (LOCK "addq %q2, %0; setz %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "ir" (value), "0" (*mem)); \ + __result; }) + + +#define atomic_increment(mem) \ + (void) ({ if (sizeof (*mem) == 1) \ + __asm __volatile (LOCK "incb %b0" \ + : "=m" (*mem) \ + : "0" (*mem)); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile (LOCK "incw %w0" \ + : "=m" (*mem) \ + : "0" (*mem)); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile (LOCK "incl %0" \ + : "=m" (*mem) \ + : "0" (*mem)); \ + else \ + __asm __volatile (LOCK "incq %q0" \ + : "=m" (*mem) \ + : "0" (*mem)); \ + }) + + +#define atomic_increment_and_test(mem) \ + ({ unsigned char __result; \ + if (sizeof (*mem) == 1) \ + __asm __volatile (LOCK "incb %b0; sete %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "0" (*mem)); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile (LOCK "incw %w0; sete %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "0" (*mem)); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile (LOCK "incl %0; sete %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "0" (*mem)); \ + else \ + __asm __volatile (LOCK "incq %q0; sete %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "0" (*mem)); \ + __result; }) + + +#define atomic_decrement(mem) \ + (void) ({ if (sizeof (*mem) == 1) \ + __asm __volatile (LOCK "decb %b0" \ + : "=m" (*mem) \ + : "0" (*mem)); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile (LOCK "decw %w0" \ + : "=m" (*mem) \ + : "0" (*mem)); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile (LOCK "decl %0" \ + : "=m" (*mem) \ + : "0" (*mem)); \ + else \ + __asm __volatile (LOCK "decq %q0" \ + : "=m" (*mem) \ + : "0" (*mem)); \ + }) + + +#define atomic_decrement_and_test(mem) \ + ({ unsigned char __result; \ + if (sizeof (*mem) == 1) \ + __asm __volatile (LOCK "decb %b0; sete %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "0" (*mem)); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile (LOCK "decw %w0; sete %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "0" (*mem)); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile (LOCK "decl %0; sete %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "0" (*mem)); \ + else \ + __asm __volatile (LOCK "decq %q0; sete %1" \ + : "=m" (*mem), "=qm" (__result) \ + : "0" (*mem)); \ + __result; }) + + +#define atomic_bit_set(mem, bit) \ + (void) ({ if (sizeof (*mem) == 1) \ + __asm __volatile (LOCK "orb %b2, %0" \ + : "=m" (*mem) \ + : "0" (*mem), "i" (1 << (bit))); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile (LOCK "orw %w2, %0" \ + : "=m" (*mem) \ + : "0" (*mem), "i" (1 << (bit))); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile (LOCK "orl %2, %0" \ + : "=m" (*mem) \ + : "0" (*mem), "i" (1 << (bit))); \ + else \ + __asm __volatile (LOCK "orq %q2, %0" \ + : "=m" (*mem) \ + : "0" (*mem), "i" (1 << (bit))); \ + }) + + +#define atomic_bit_test_set(mem, bit) \ + ({ unsigned char __result; \ + if (sizeof (*mem) == 1) \ + __asm __volatile (LOCK "btsb %3, %1; setc %0" \ + : "=q" (__result), "=m" (*mem) \ + : "1" (*mem), "i" (bit)); \ + else if (sizeof (*mem) == 2) \ + __asm __volatile (LOCK "btsw %3, %1; setc %0" \ + : "=q" (__result), "=m" (*mem) \ + : "1" (*mem), "i" (bit)); \ + else if (sizeof (*mem) == 4) \ + __asm __volatile (LOCK "btsl %3, %1; setc %0" \ + : "=q" (__result), "=m" (*mem) \ + : "1" (*mem), "i" (bit)); \ + else \ + __asm __volatile (LOCK "btsq %3, %1; setc %0" \ + : "=q" (__result), "=m" (*mem) \ + : "1" (*mem), "i" (bit)); \ + __result; }) -- cgit v1.2.3