Define atomic_max and atomic_min.
[kopensolaris-gnu/glibc.git] / include / atomic.h
index 3063037..8b76435 100644 (file)
@@ -1,4 +1,5 @@
-/* Copyright (C) 2002, 2003 Free Software Foundation, Inc.
+/* Internal macros for atomic operations for GNU C Library.
+   Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
 
 
 #include <bits/atomic.h>
 
+/* Wrapper macros to call pre_NN_post (mem, ...) where NN is the
+   bit width of *MEM.  The calling macro puts parens around MEM
+   and following args.  */
+#define __atomic_val_bysize(pre, post, mem, ...)                             \
+  ({                                                                         \
+    __typeof (*mem) __result;                                                \
+    if (sizeof (*mem) == 1)                                                  \
+      __result = pre##_8_##post (mem, __VA_ARGS__);                          \
+    else if (sizeof (*mem) == 2)                                             \
+      __result = pre##_16_##post (mem, __VA_ARGS__);                         \
+    else if (sizeof (*mem) == 4)                                             \
+      __result = pre##_32_##post (mem, __VA_ARGS__);                         \
+    else if (sizeof (*mem) == 8)                                             \
+      __result = pre##_64_##post (mem, __VA_ARGS__);                         \
+    else                                                                     \
+      abort ();                                                                      \
+    __result;                                                                \
+  })
+#define __atomic_bool_bysize(pre, post, mem, ...)                            \
+  ({                                                                         \
+    int __result;                                                            \
+    if (sizeof (*mem) == 1)                                                  \
+      __result = pre##_8_##post (mem, __VA_ARGS__);                          \
+    else if (sizeof (*mem) == 2)                                             \
+      __result = pre##_16_##post (mem, __VA_ARGS__);                         \
+    else if (sizeof (*mem) == 4)                                             \
+      __result = pre##_32_##post (mem, __VA_ARGS__);                         \
+    else if (sizeof (*mem) == 8)                                             \
+      __result = pre##_64_##post (mem, __VA_ARGS__);                         \
+    else                                                                     \
+      abort ();                                                                      \
+    __result;                                                                \
+  })
+
 
-#ifndef atomic_compare_and_exchange_val_acq
+/* Atomically store NEWVAL in *MEM if *MEM is equal to OLDVAL.
+   Return the old *MEM value.  */
+#if !defined atomic_compare_and_exchange_val_acq \
+    && defined __arch_compare_and_exchange_val_32_acq
 # define atomic_compare_and_exchange_val_acq(mem, newval, oldval) \
-  ({ __typeof (*mem) __result;                                               \
-     if (sizeof (*mem) == 1)                                                 \
-       __result = __arch_compare_and_exchange_val_8_acq (mem, newval, oldval);\
-     else if (sizeof (*mem) == 2)                                            \
-       __result = __arch_compare_and_exchange_val_16_acq (mem, newval,oldval);\
-     else if (sizeof (*mem) == 4)                                            \
-       __result = __arch_compare_and_exchange_val_32_acq (mem, newval,oldval);\
-     else if (sizeof (*mem) == 8)                                            \
-       __result = __arch_compare_and_exchange_val_64_acq (mem, newval,oldval);\
-     else                                                                    \
-       abort ();                                                             \
-     __result; })
+  __atomic_val_bysize (__arch_compare_and_exchange_val,acq,                  \
+                      mem, newval, oldval)
 #endif
 
 
 #ifndef atomic_compare_and_exchange_val_rel
-# define atomic_compare_and_exchange_val_rel(mem, oldval, newval) \
-  atomic_compare_and_exchange_val_acq (mem, oldval, newval)
+# define atomic_compare_and_exchange_val_rel(mem, newval, oldval)            \
+  atomic_compare_and_exchange_val_acq (mem, newval, oldval)
 #endif
 
 
+/* Atomically store NEWVAL in *MEM if *MEM is equal to OLDVAL.
+   Return zero if *MEM was changed or non-zero if no exchange happened.  */
 #ifndef atomic_compare_and_exchange_bool_acq
 # ifdef __arch_compare_and_exchange_bool_32_acq
-#  define atomic_compare_and_exchange_val_acq(mem, newval, oldval) \
-  ({ __typeof (__arch_compare_and_exchange_bool_32_acq (mem, 0, 0)) __result; \
-     if (sizeof (*mem) == 1)                                                 \
-       __result = __arch_compare_and_exchange_bool_8_acq (mem, newval,       \
-                                                         oldval);            \
-     else if (sizeof (*mem) == 2)                                            \
-       __result = __arch_compare_and_exchange_bool_16_acq (mem, newval,              \
-                                                          oldval);           \
-     else if (sizeof (*mem) == 4)                                            \
-       __result = __arch_compare_and_exchange_bool_32_acq (mem, newval,              \
-                                                          oldval);           \
-     else if (sizeof (*mem) == 8)                                            \
-       __result = __arch_compare_and_exchange_bool_64_acq (mem, newval,              \
-                                                          oldval);           \
-     else                                                                    \
-       abort ();                                                             \
-     __result; })
-# else
 #  define atomic_compare_and_exchange_bool_acq(mem, newval, oldval) \
-  ({ __typeof (oldval) __oldval = (oldval);                                  \
-     atomic_compare_and_exchange_val_acq (mem, newval, __oldval) != __oldval; \
+  __atomic_bool_bysize (__arch_compare_and_exchange_bool,acq,                \
+                       mem, newval, oldval)
+#  else
+#   define atomic_compare_and_exchange_bool_acq(mem, newval, oldval) \
+  ({ /* Cannot use __oldval here, because macros later in this file might     \
+       call this macro with __oldval argument.  */                           \
+     __typeof (oldval) __old = (oldval);                                     \
+     atomic_compare_and_exchange_val_acq (mem, newval, __old) != __old;              \
   })
 # endif
 #endif
 
 
 #ifndef atomic_compare_and_exchange_bool_rel
-# define atomic_compare_and_exchange_bool_rel(mem, oldval, newval) \
-  atomic_compare_and_exchange_bool_acq (mem, oldval, newval)
+# define atomic_compare_and_exchange_bool_rel(mem, newval, oldval) \
+  atomic_compare_and_exchange_bool_acq (mem, newval, oldval)
 #endif
 
 
 /* Store NEWVALUE in *MEM and return the old value.  */
-#ifndef atomic_exchange
-# define atomic_exchange(mem, newvalue) \
-  ({ __typeof (*mem) __oldval;                                               \
+#ifndef atomic_exchange_acq
+# define atomic_exchange_acq(mem, newvalue) \
+  ({ __typeof (*(mem)) __oldval;                                             \
      __typeof (mem) __memp = (mem);                                          \
-     __typeof (*mem) __value = (newvalue);                                   \
+     __typeof (*(mem)) __value = (newvalue);                                 \
                                                                              \
      do                                                                              \
-       __oldval = (*__memp);                                                 \
+       __oldval = *__memp;                                                   \
      while (__builtin_expect (atomic_compare_and_exchange_bool_acq (__memp,   \
                                                                    __value,  \
                                                                    __oldval),\
      __oldval; })
 #endif
 
+#ifndef atomic_exchange_rel
+# define atomic_exchange_rel(mem, newvalue) atomic_exchange_acq (mem, newvalue)
+#endif
+
 
 /* Add VALUE to *MEM and return the old value of *MEM.  */
 #ifndef atomic_exchange_and_add
 # define atomic_exchange_and_add(mem, value) \
-  ({ __typeof (*mem) __oldval;                                               \
+  ({ __typeof (*(mem)) __oldval;                                             \
      __typeof (mem) __memp = (mem);                                          \
-     __typeof (*mem) __value = (value);                                              \
+     __typeof (*(mem)) __value = (value);                                    \
                                                                              \
      do                                                                              \
-       __oldval = (*__memp);                                                 \
+       __oldval = *__memp;                                                   \
      while (__builtin_expect (atomic_compare_and_exchange_bool_acq (__memp,   \
                                                                    __oldval  \
                                                                    + __value,\
 #endif
 
 
+
+#ifndef atomic_max
+# define atomic_max(mem, value) \
+  do {                                                                       \
+    __typeof (*(mem)) __oldval;                                                      \
+    __typeof (mem) __memp = (mem);                                           \
+    __typeof (*(mem)) __value = (value);                                     \
+    do {                                                                     \
+      __oldval = *__memp;                                                    \
+      if (__oldval >= __value)                                               \
+       break;                                                                \
+    } while (__builtin_expect (atomic_compare_and_exchange_bool_acq (__memp,  \
+                                                                    __value, \
+                                                                    __oldval),\
+                              0));                                           \
+  } while (0)
+#endif
+
+#ifndef atomic_min
+# define atomic_min(mem, value) \
+  do {                                                                       \
+    __typeof (*(mem)) __oldval;                                                      \
+    __typeof (mem) __memp = (mem);                                           \
+    __typeof (*(mem)) __value = (value);                                     \
+    do {                                                                     \
+      __oldval = *__memp;                                                    \
+      if (__oldval <= __value)                                               \
+       break;                                                                \
+    } while (__builtin_expect (atomic_compare_and_exchange_bool_acq (__memp,  \
+                                                                    __value, \
+                                                                    __oldval),\
+                              0));                                           \
+  } while (0)
+#endif
+
 #ifndef atomic_add
-# define atomic_add(mem, value) (void) atomic_exchange_and_add (mem, value)
+# define atomic_add(mem, value) (void) atomic_exchange_and_add ((mem), (value))
 #endif
 
 
 #ifndef atomic_increment
-# define atomic_increment(mem) atomic_add (mem, 1)
+# define atomic_increment(mem) atomic_add ((mem), 1)
+#endif
+
+
+#ifndef atomic_increment_val
+# define atomic_increment_val(mem) (atomic_exchange_and_add ((mem), 1) + 1)
 #endif
 
 
+/* Add one to *MEM and return true iff it's now zero.  */
 #ifndef atomic_increment_and_test
 # define atomic_increment_and_test(mem) \
-  (atomic_exchange_and_add (mem, 1) == 0)
+  (atomic_exchange_and_add ((mem), 1) + 1 == 0)
 #endif
 
 
 #ifndef atomic_decrement
-# define atomic_decrement(mem) atomic_add (mem, -1)
+# define atomic_decrement(mem) atomic_add ((mem), -1)
 #endif
 
 
+#ifndef atomic_decrement_val
+# define atomic_decrement_val(mem) (atomic_exchange_and_add ((mem), -1) - 1)
+#endif
+
+
+/* Subtract 1 from *MEM and return true iff it's now zero.  */
 #ifndef atomic_decrement_and_test
 # define atomic_decrement_and_test(mem) \
-  (atomic_exchange_and_add (mem, -1) == 0)
+  (atomic_exchange_and_add ((mem), -1) == 1)
 #endif
 
 
 /* Decrement *MEM if it is > 0, and return the old value.  */
 #ifndef atomic_decrement_if_positive
 # define atomic_decrement_if_positive(mem) \
-  ({ __typeof (*mem) __oldval;                                               \
-     __typeof (mem) __memp;                                                  \
+  ({ __typeof (*(mem)) __oldval;                                             \
+     __typeof (mem) __memp = (mem);                                          \
                                                                              \
-     __val = *__memp;                                                        \
      do                                                                              \
        {                                                                     \
         __oldval = *__memp;                                                  \
 
 
 #ifndef atomic_add_negative
-# define atomic_add_negative(mem, value) \
-  (atomic_exchange_and_add (mem, value) < 0)
+# define atomic_add_negative(mem, value)                                     \
+  ({ __typeof (value) __aan_value = (value);                                 \
+     atomic_exchange_and_add (mem, __aan_value) < -__aan_value; })
 #endif
 
 
 #ifndef atomic_add_zero
-# define atomic_add_zero(mem, value) \
-  (atomic_exchange_and_add (mem, value) == 0)
+# define atomic_add_zero(mem, value)                                         \
+  ({ __typeof (value) __aaz_value = (value);                                 \
+     atomic_exchange_and_add (mem, __aaz_value) == -__aaz_value; })
 #endif
 
 
 
 #ifndef atomic_bit_test_set
 # define atomic_bit_test_set(mem, bit) \
-  ({ __typeof (*mem) __oldval;                                               \
+  ({ __typeof (*(mem)) __oldval;                                             \
      __typeof (mem) __memp = (mem);                                          \
-     __typeof (*mem) __mask = (1 << (bit));                                  \
+     __typeof (*(mem)) __mask = ((__typeof (*(mem))) 1 << (bit));            \
                                                                              \
      do                                                                              \
        __oldval = (*__memp);                                                 \
 
 
 #ifndef atomic_read_barrier
-# define atomic_read_barrier() atomic_full_barrier()
+# define atomic_read_barrier() atomic_full_barrier ()
 #endif
 
 
 #ifndef atomic_write_barrier
-# define atomic_write_barrier() atomic_full_barrier()
+# define atomic_write_barrier() atomic_full_barrier ()
+#endif
+
+
+#ifndef atomic_delay
+# define atomic_delay() do { /* nothing */ } while (0)
 #endif
 
 #endif /* atomic.h */