Update copyright notices with scripts/update-copyrights

[thirdparty/glibc.git] / sysdeps / sparc / sparc64 / bits / atomic.h

diff --git a/sysdeps/sparc/sparc64/bits/atomic.h b/sysdeps/sparc/sparc64/bits/atomic.h
index 4df3b2556ac9acea7b15edd7892d8f061ac9bace..ad9dae1d0fd761cfde4a8c6181195e8c954696e0 100644 (file)
--- a/sysdeps/sparc/sparc64/bits/atomic.h
+++ b/sysdeps/sparc/sparc64/bits/atomic.h
@@ -1,5 +1,5 @@
 /* Atomic operations.  sparc64 version.
-   Copyright (C) 2003 Free Software Foundation, Inc.
+   Copyright (C) 2003-2014 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Jakub Jelinek <jakub@redhat.com>, 2003.
 
@@ -14,9 +14,8 @@
    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.  */
+   License along with the GNU C Library; if not, see
+   <http://www.gnu.org/licenses/>.  */
 
 #include <stdint.h>
 
@@ -56,23 +55,35 @@ typedef uintmax_t uatomic_max_t;
 ({                                                                           \
   __typeof (*(mem)) __acev_tmp;                                                      \
   __typeof (mem) __acev_mem = (mem);                                         \
-  __asm __volatile ("cas [%4], %2, %0"                                       \
-                   : "=r" (__acev_tmp), "=m" (*__acev_mem)                   \
-                   : "r" (oldval), "m" (*__acev_mem), "r" (__acev_mem),      \
-                     "0" (newval));                                          \
+  if (__builtin_constant_p (oldval) && (oldval) == 0)                        \
+    __asm __volatile ("cas [%3], %%g0, %0"                                   \
+                     : "=r" (__acev_tmp), "=m" (*__acev_mem)                 \
+                     : "m" (*__acev_mem), "r" (__acev_mem),                  \
+                       "0" (newval) : "memory");                             \
+  else                                                                       \
+    __asm __volatile ("cas [%4], %2, %0"                                     \
+                     : "=r" (__acev_tmp), "=m" (*__acev_mem)                 \
+                     : "r" (oldval), "m" (*__acev_mem), "r" (__acev_mem),    \
+                       "0" (newval) : "memory");                             \
   __acev_tmp; })
 
 #define __arch_compare_and_exchange_val_64_acq(mem, newval, oldval) \
 ({                                                                           \
   __typeof (*(mem)) __acev_tmp;                                                      \
   __typeof (mem) __acev_mem = (mem);                                         \
-  __asm __volatile ("casx [%4], %2, %0"                                              \
-                   : "=r" (__acev_tmp), "=m" (*__acev_mem)                   \
-                   : "r" ((long) (oldval)), "m" (*__acev_mem),               \
-                     "r" (__acev_mem), "0" ((long) (newval)));               \
+  if (__builtin_constant_p (oldval) && (oldval) == 0)                        \
+    __asm __volatile ("casx [%3], %%g0, %0"                                  \
+                     : "=r" (__acev_tmp), "=m" (*__acev_mem)                 \
+                     : "m" (*__acev_mem), "r" (__acev_mem),                  \
+                       "0" ((long) (newval)) : "memory");                    \
+  else                                                                       \
+    __asm __volatile ("casx [%4], %2, %0"                                    \
+                     : "=r" (__acev_tmp), "=m" (*__acev_mem)                 \
+                     : "r" ((long) (oldval)), "m" (*__acev_mem),             \
+                       "r" (__acev_mem), "0" ((long) (newval)) : "memory");  \
   __acev_tmp; })
 
-#define atomic_exchange(mem, newvalue) \
+#define atomic_exchange_acq(mem, newvalue) \
   ({ __typeof (*(mem)) __oldval, __val;                                              \
      __typeof (mem) __memp = (mem);                                          \
      __typeof (*(mem)) __value = (newvalue);                                 \
@@ -80,7 +91,7 @@ typedef uintmax_t uatomic_max_t;
      if (sizeof (*(mem)) == 4)                                               \
        __asm ("swap %0, %1"                                                  \
              : "=m" (*__memp), "=r" (__oldval)                               \
-             : "m" (*__memp), "1" (__value));                                \
+             : "m" (*__memp), "1" (__value) : "memory");                     \
      else                                                                    \
        {                                                                     \
         __val = *__memp;                                                     \
@@ -94,6 +105,12 @@ typedef uintmax_t uatomic_max_t;
        }                                                                     \
      __oldval; })
 
+#define atomic_compare_and_exchange_val_24_acq(mem, newval, oldval) \
+  atomic_compare_and_exchange_val_acq (mem, newval, oldval)
+
+#define atomic_exchange_24_rel(mem, newval) \
+  atomic_exchange_rel (mem, newval)
+
 #define atomic_full_barrier() \
   __asm __volatile ("membar #LoadLoad | #LoadStore"                          \
                          " | #StoreLoad | #StoreStore" : : : "memory")