Back to index

glibc  2.9
Defines | Typedefs
atomic.h File Reference
#include <stdint.h>
#include <tls.h>

Go to the source code of this file.

Defines

#define LOCK_PREFIX   "lock;"
#define __arch_compare_and_exchange_val_8_acq(mem, newval, oldval)
#define __arch_compare_and_exchange_val_16_acq(mem, newval, oldval)
#define __arch_compare_and_exchange_val_32_acq(mem, newval, oldval)
#define __arch_compare_and_exchange_val_64_acq(mem, newval, oldval)
#define __arch_c_compare_and_exchange_val_8_acq(mem, newval, oldval)
#define __arch_c_compare_and_exchange_val_16_acq(mem, newval, oldval)
#define __arch_c_compare_and_exchange_val_32_acq(mem, newval, oldval)
#define __arch_c_compare_and_exchange_val_64_acq(mem, newval, oldval)
#define atomic_exchange_acq(mem, newvalue)
#define __arch_exchange_and_add_body(lock, mem, value)
#define atomic_exchange_and_add(mem, value)   __arch_exchange_and_add_body (LOCK_PREFIX, mem, value)
#define __arch_exchange_and_add_cprefix   "cmpl $0, %%fs:%P4\n\tje 0f\n\tlock\n0:\t"
#define catomic_exchange_and_add(mem, value)   __arch_exchange_and_add_body (__arch_exchange_and_add_cprefix, mem, value)
#define __arch_add_body(lock, pfx, mem, value)
#define atomic_add(mem, value)   __arch_add_body (LOCK_PREFIX, atomic, mem, value)
#define __arch_add_cprefix   "cmpl $0, %%fs:%P3\n\tje 0f\n\tlock\n0:\t"
#define catomic_add(mem, value)   __arch_add_body (__arch_add_cprefix, catomic, mem, value)
#define atomic_add_negative(mem, value)
#define atomic_add_zero(mem, value)
#define __arch_increment_body(lock, mem)
#define atomic_increment(mem)   __arch_increment_body (LOCK_PREFIX, mem)
#define __arch_increment_cprefix   "cmpl $0, %%fs:%P2\n\tje 0f\n\tlock\n0:\t"
#define catomic_increment(mem)   __arch_increment_body (__arch_increment_cprefix, mem)
#define atomic_increment_and_test(mem)
#define __arch_decrement_body(lock, mem)
#define atomic_decrement(mem)   __arch_decrement_body (LOCK_PREFIX, mem)
#define __arch_decrement_cprefix   "cmpl $0, %%fs:%P2\n\tje 0f\n\tlock\n0:\t"
#define catomic_decrement(mem)   __arch_decrement_body (__arch_decrement_cprefix, mem)
#define atomic_decrement_and_test(mem)
#define atomic_bit_set(mem, bit)
#define atomic_bit_test_set(mem, bit)
#define atomic_delay()   asm ("rep; nop")
#define atomic_and(mem, mask)
#define __arch_or_body(lock, mem, mask)
#define atomic_or(mem, mask)   __arch_or_body (LOCK_PREFIX, mem, mask)
#define __arch_or_cprefix   "cmpl $0, %%fs:%P3\n\tje 0f\n\tlock\n0:\t"
#define catomic_or(mem, mask)   __arch_or_body (__arch_or_cprefix, mem, mask)

Typedefs

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 Documentation

#define __arch_add_body (   lock,
  pfx,
  mem,
  value 
)
Value:
do {                                                                 \
    if (__builtin_constant_p (value) && (value) == 1)                       \
      pfx##_increment (mem);                                                \
    else if (__builtin_constant_p (value) && (value) == -1)                 \
      pfx##_decrement (mem);                                                \
    else if (sizeof (*mem) == 1)                                     \
      __asm __volatile (lock "addb %b1, %0"                                 \
                     : "=m" (*mem)                                   \
                     : "iq" (value), "m" (*mem),                     \
                       "i" (offsetof (tcbhead_t, multiple_threads)));      \
    else if (sizeof (*mem) == 2)                                     \
      __asm __volatile (lock "addw %w1, %0"                                 \
                     : "=m" (*mem)                                   \
                     : "ir" (value), "m" (*mem),                     \
                       "i" (offsetof (tcbhead_t, multiple_threads)));      \
    else if (sizeof (*mem) == 4)                                     \
      __asm __volatile (lock "addl %1, %0"                                  \
                     : "=m" (*mem)                                   \
                     : "ir" (value), "m" (*mem),                     \
                       "i" (offsetof (tcbhead_t, multiple_threads)));      \
    else                                                             \
      __asm __volatile (lock "addq %q1, %0"                                 \
                     : "=m" (*mem)                                   \
                     : "ir" ((long) (value)), "m" (*mem),                   \
                       "i" (offsetof (tcbhead_t, multiple_threads)));      \
  } while (0)

Definition at line 203 of file atomic.h.

#define __arch_add_cprefix   "cmpl $0, %%fs:%P3\n\tje 0f\n\tlock\n0:\t"

Definition at line 234 of file atomic.h.

#define __arch_c_compare_and_exchange_val_16_acq (   mem,
  newval,
  oldval 
)
Value:
({ __typeof (*mem) ret;                                              \
    __asm __volatile ("cmpl $0, %%fs:%P5\n\t"                               \
                    "je 0f\n\t"                                      \
                    "lock\n"                                                \
                     "0:\tcmpxchgw %w2, %1"                                 \
                     : "=a" (ret), "=m" (*mem)                       \
                     : "q" (newval), "m" (*mem), "0" (oldval),       \
                      "i" (offsetof (tcbhead_t, multiple_threads)));        \
     ret; })

Definition at line 107 of file atomic.h.

#define __arch_c_compare_and_exchange_val_32_acq (   mem,
  newval,
  oldval 
)
Value:
({ __typeof (*mem) ret;                                              \
    __asm __volatile ("cmpl $0, %%fs:%P5\n\t"                               \
                    "je 0f\n\t"                                      \
                    "lock\n"                                                \
                     "0:\tcmpxchgl %2, %1"                                  \
                     : "=a" (ret), "=m" (*mem)                       \
                     : "q" (newval), "m" (*mem), "0" (oldval),       \
                      "i" (offsetof (tcbhead_t, multiple_threads)));        \
     ret; })

Definition at line 118 of file atomic.h.

#define __arch_c_compare_and_exchange_val_64_acq (   mem,
  newval,
  oldval 
)
Value:
({ __typeof (*mem) ret;                                              \
     __asm __volatile ("cmpl $0, %%fs:%P5\n\t"                              \
                     "je 0f\n\t"                                     \
                     "lock\n"                                               \
                     "0:\tcmpxchgq %q2, %1"                                 \
                     : "=a" (ret), "=m" (*mem)                       \
                     : "q" ((long int) (newval)), "m" (*mem),               \
                      "0" ((long int)oldval),                        \
                      "i" (offsetof (tcbhead_t, multiple_threads)));        \
     ret; })

Definition at line 129 of file atomic.h.

#define __arch_c_compare_and_exchange_val_8_acq (   mem,
  newval,
  oldval 
)
Value:
({ __typeof (*mem) ret;                                              \
    __asm __volatile ("cmpl $0, %%fs:%P5\n\t"                               \
                    "je 0f\n\t"                                      \
                    "lock\n"                                                \
                     "0:\tcmpxchgb %b2, %1"                                 \
                     : "=a" (ret), "=m" (*mem)                       \
                     : "q" (newval), "m" (*mem), "0" (oldval),       \
                      "i" (offsetof (tcbhead_t, multiple_threads)));        \
     ret; })

Definition at line 96 of file atomic.h.

#define __arch_compare_and_exchange_val_16_acq (   mem,
  newval,
  oldval 
)
Value:
({ __typeof (*mem) ret;                                              \
     __asm __volatile (LOCK_PREFIX "cmpxchgw %w2, %1"                       \
                     : "=a" (ret), "=m" (*mem)                       \
                     : "r" (newval), "m" (*mem), "0" (oldval));             \
     ret; })

Definition at line 72 of file atomic.h.

#define __arch_compare_and_exchange_val_32_acq (   mem,
  newval,
  oldval 
)
Value:
({ __typeof (*mem) ret;                                              \
     __asm __volatile (LOCK_PREFIX "cmpxchgl %2, %1"                        \
                     : "=a" (ret), "=m" (*mem)                       \
                     : "r" (newval), "m" (*mem), "0" (oldval));             \
     ret; })

Definition at line 79 of file atomic.h.

#define __arch_compare_and_exchange_val_64_acq (   mem,
  newval,
  oldval 
)
Value:
({ __typeof (*mem) ret;                                              \
     __asm __volatile (LOCK_PREFIX "cmpxchgq %q2, %1"                       \
                     : "=a" (ret), "=m" (*mem)                       \
                     : "r" ((long int) (newval)), "m" (*mem),               \
                      "0" ((long int) (oldval)));                           \
     ret; })

Definition at line 86 of file atomic.h.

#define __arch_compare_and_exchange_val_8_acq (   mem,
  newval,
  oldval 
)
Value:
({ __typeof (*mem) ret;                                              \
     __asm __volatile (LOCK_PREFIX "cmpxchgb %b2, %1"                       \
                     : "=a" (ret), "=m" (*mem)                       \
                     : "q" (newval), "m" (*mem), "0" (oldval));             \
     ret; })

Definition at line 65 of file atomic.h.

#define __arch_decrement_body (   lock,
  mem 
)
Value:
do {                                                                 \
    if (sizeof (*mem) == 1)                                          \
      __asm __volatile (lock "decb %b0"                                     \
                     : "=m" (*mem)                                   \
                     : "m" (*mem),                                   \
                       "i" (offsetof (tcbhead_t, multiple_threads)));      \
    else if (sizeof (*mem) == 2)                                     \
      __asm __volatile (lock "decw %w0"                                     \
                     : "=m" (*mem)                                   \
                     : "m" (*mem),                                   \
                       "i" (offsetof (tcbhead_t, multiple_threads)));      \
    else if (sizeof (*mem) == 4)                                     \
      __asm __volatile (lock "decl %0"                                      \
                     : "=m" (*mem)                                   \
                     : "m" (*mem),                                   \
                       "i" (offsetof (tcbhead_t, multiple_threads)));      \
    else                                                             \
      __asm __volatile (lock "decq %q0"                                     \
                     : "=m" (*mem)                                   \
                     : "m" (*mem),                                   \
                       "i" (offsetof (tcbhead_t, multiple_threads)));      \
  } while (0)

Definition at line 337 of file atomic.h.

#define __arch_decrement_cprefix   "cmpl $0, %%fs:%P2\n\tje 0f\n\tlock\n0:\t"

Definition at line 363 of file atomic.h.

#define __arch_exchange_and_add_body (   lock,
  mem,
  value 
)
Value:
({ __typeof (*mem) result;                                           \
     if (sizeof (*mem) == 1)                                                \
       __asm __volatile (lock "xaddb %b0, %1"                               \
                      : "=q" (result), "=m" (*mem)                          \
                      : "0" (value), "m" (*mem),                     \
                        "i" (offsetof (tcbhead_t, multiple_threads)));     \
     else if (sizeof (*mem) == 2)                                    \
       __asm __volatile (lock "xaddw %w0, %1"                               \
                      : "=r" (result), "=m" (*mem)                          \
                      : "0" (value), "m" (*mem),                     \
                        "i" (offsetof (tcbhead_t, multiple_threads)));     \
     else if (sizeof (*mem) == 4)                                    \
       __asm __volatile (lock "xaddl %0, %1"                                \
                      : "=r" (result), "=m" (*mem)                          \
                      : "0" (value), "m" (*mem),                     \
                        "i" (offsetof (tcbhead_t, multiple_threads)));     \
     else                                                            \
       __asm __volatile (lock "xaddq %q0, %1"                               \
                      : "=r" (result), "=m" (*mem)                          \
                      : "0" ((long) (value)), "m" (*mem),                   \
                        "i" (offsetof (tcbhead_t, multiple_threads)));     \
     result; })

Definition at line 164 of file atomic.h.

#define __arch_exchange_and_add_cprefix   "cmpl $0, %%fs:%P4\n\tje 0f\n\tlock\n0:\t"

Definition at line 196 of file atomic.h.

#define __arch_increment_body (   lock,
  mem 
)
Value:
do {                                                                 \
    if (sizeof (*mem) == 1)                                          \
      __asm __volatile (lock "incb %b0"                                     \
                     : "=m" (*mem)                                   \
                     : "m" (*mem),                                   \
                       "i" (offsetof (tcbhead_t, multiple_threads)));      \
    else if (sizeof (*mem) == 2)                                     \
      __asm __volatile (lock "incw %w0"                                     \
                     : "=m" (*mem)                                   \
                     : "m" (*mem),                                   \
                       "i" (offsetof (tcbhead_t, multiple_threads)));      \
    else if (sizeof (*mem) == 4)                                     \
      __asm __volatile (lock "incl %0"                                      \
                     : "=m" (*mem)                                   \
                     : "m" (*mem),                                   \
                       "i" (offsetof (tcbhead_t, multiple_threads)));      \
    else                                                             \
      __asm __volatile (lock "incq %q0"                                     \
                     : "=m" (*mem)                                   \
                     : "m" (*mem),                                   \
                       "i" (offsetof (tcbhead_t, multiple_threads)));      \
  } while (0)

Definition at line 283 of file atomic.h.

#define __arch_increment_cprefix   "cmpl $0, %%fs:%P2\n\tje 0f\n\tlock\n0:\t"

Definition at line 309 of file atomic.h.

#define __arch_or_body (   lock,
  mem,
  mask 
)
Value:
do {                                                                 \
    if (sizeof (*mem) == 1)                                          \
      __asm __volatile (lock "orb %b1, %0"                                  \
                     : "=m" (*mem)                                   \
                     : "iq" (mask), "m" (*mem),                      \
                       "i" (offsetof (tcbhead_t, multiple_threads)));      \
    else if (sizeof (*mem) == 2)                                     \
      __asm __volatile (lock "orw %w1, %0"                                  \
                     : "=m" (*mem)                                   \
                     : "ir" (mask), "m" (*mem),                      \
                       "i" (offsetof (tcbhead_t, multiple_threads)));      \
    else if (sizeof (*mem) == 4)                                     \
      __asm __volatile (lock "orl %1, %0"                            \
                     : "=m" (*mem)                                   \
                     : "ir" (mask), "m" (*mem),                      \
                       "i" (offsetof (tcbhead_t, multiple_threads)));      \
    else                                                             \
      __asm __volatile (lock "orq %q1, %0"                                  \
                     : "=m" (*mem)                                   \
                     : "ir" (mask), "m" (*mem),                      \
                       "i" (offsetof (tcbhead_t, multiple_threads)));      \
  } while (0)

Definition at line 461 of file atomic.h.

#define __arch_or_cprefix   "cmpl $0, %%fs:%P3\n\tje 0f\n\tlock\n0:\t"

Definition at line 487 of file atomic.h.

#define atomic_add (   mem,
  value 
)    __arch_add_body (LOCK_PREFIX, atomic, mem, value)

Definition at line 231 of file atomic.h.

#define atomic_add_negative (   mem,
  value 
)
Value:
({ unsigned char __result;                                           \
     if (sizeof (*mem) == 1)                                                \
       __asm __volatile (LOCK_PREFIX "addb %b2, %0; sets %1"                \
                      : "=m" (*mem), "=qm" (__result)                \
                      : "iq" (value), "m" (*mem));                          \
     else if (sizeof (*mem) == 2)                                    \
       __asm __volatile (LOCK_PREFIX "addw %w2, %0; sets %1"                \
                      : "=m" (*mem), "=qm" (__result)                \
                      : "ir" (value), "m" (*mem));                          \
     else if (sizeof (*mem) == 4)                                    \
       __asm __volatile (LOCK_PREFIX "addl %2, %0; sets %1"                 \
                      : "=m" (*mem), "=qm" (__result)                \
                      : "ir" (value), "m" (*mem));                          \
     else                                                            \
       __asm __volatile (LOCK_PREFIX "addq %q2, %0; sets %1"                \
                      : "=m" (*mem), "=qm" (__result)                \
                      : "ir" ((long) (value)), "m" (*mem));                 \
     __result; })

Definition at line 241 of file atomic.h.

#define atomic_add_zero (   mem,
  value 
)
Value:
({ unsigned char __result;                                           \
     if (sizeof (*mem) == 1)                                                \
       __asm __volatile (LOCK_PREFIX "addb %b2, %0; setz %1"                \
                      : "=m" (*mem), "=qm" (__result)                \
                      : "iq" (value), "m" (*mem));                          \
     else if (sizeof (*mem) == 2)                                    \
       __asm __volatile (LOCK_PREFIX "addw %w2, %0; setz %1"                \
                      : "=m" (*mem), "=qm" (__result)                \
                      : "ir" (value), "m" (*mem));                          \
     else if (sizeof (*mem) == 4)                                    \
       __asm __volatile (LOCK_PREFIX "addl %2, %0; setz %1"                 \
                      : "=m" (*mem), "=qm" (__result)                \
                      : "ir" (value), "m" (*mem));                          \
     else                                                            \
       __asm __volatile (LOCK_PREFIX "addq %q2, %0; setz %1"                \
                      : "=m" (*mem), "=qm" (__result)                \
                      : "ir" ((long) (value)), "m" (*mem));                 \
     __result; })

Definition at line 262 of file atomic.h.

#define atomic_and (   mem,
  mask 
)
Value:
do {                                                                 \
    if (sizeof (*mem) == 1)                                          \
      __asm __volatile (LOCK_PREFIX "andb %b1, %0"                          \
                     : "=m" (*mem)                                   \
                     : "iq" (mask), "m" (*mem));                     \
    else if (sizeof (*mem) == 2)                                     \
      __asm __volatile (LOCK_PREFIX "andw %w1, %0"                          \
                     : "=m" (*mem)                                   \
                     : "ir" (mask), "m" (*mem));                     \
    else if (sizeof (*mem) == 4)                                     \
      __asm __volatile (LOCK_PREFIX "andl %1, %0"                           \
                     : "=m" (*mem)                                   \
                     : "ir" (mask), "m" (*mem));                     \
    else                                                             \
      __asm __volatile (LOCK_PREFIX "andq %q1, %0"                          \
                     : "=m" (*mem)                                   \
                     : "ir" (mask), "m" (*mem));                     \
  } while (0)

Definition at line 440 of file atomic.h.

#define atomic_bit_set (   mem,
  bit 
)
Value:
do {                                                                 \
    if (sizeof (*mem) == 1)                                          \
      __asm __volatile (LOCK_PREFIX "orb %b2, %0"                           \
                     : "=m" (*mem)                                   \
                     : "m" (*mem), "iq" (1L << (bit)));              \
    else if (sizeof (*mem) == 2)                                     \
      __asm __volatile (LOCK_PREFIX "orw %w2, %0"                           \
                     : "=m" (*mem)                                   \
                     : "m" (*mem), "ir" (1L << (bit)));              \
    else if (sizeof (*mem) == 4)                                     \
      __asm __volatile (LOCK_PREFIX "orl %2, %0"                     \
                     : "=m" (*mem)                                   \
                     : "m" (*mem), "ir" (1L << (bit)));              \
    else if (__builtin_constant_p (bit) && (bit) < 32)                      \
      __asm __volatile (LOCK_PREFIX "orq %2, %0"                     \
                     : "=m" (*mem)                                   \
                     : "m" (*mem), "i" (1L << (bit)));               \
    else                                                             \
      __asm __volatile (LOCK_PREFIX "orq %q2, %0"                           \
                     : "=m" (*mem)                                   \
                     : "m" (*mem), "r" (1UL << (bit)));              \
  } while (0)

Definition at line 391 of file atomic.h.

#define atomic_bit_test_set (   mem,
  bit 
)
Value:
({ unsigned char __result;                                           \
     if (sizeof (*mem) == 1)                                                \
       __asm __volatile (LOCK_PREFIX "btsb %3, %1; setc %0"                 \
                      : "=q" (__result), "=m" (*mem)                        \
                      : "m" (*mem), "iq" (bit));                     \
     else if (sizeof (*mem) == 2)                                    \
       __asm __volatile (LOCK_PREFIX "btsw %3, %1; setc %0"                 \
                      : "=q" (__result), "=m" (*mem)                        \
                      : "m" (*mem), "ir" (bit));                     \
     else if (sizeof (*mem) == 4)                                    \
       __asm __volatile (LOCK_PREFIX "btsl %3, %1; setc %0"                 \
                      : "=q" (__result), "=m" (*mem)                        \
                      : "m" (*mem), "ir" (bit));                     \
     else                                                            \
       __asm __volatile (LOCK_PREFIX "btsq %3, %1; setc %0"                 \
                      : "=q" (__result), "=m" (*mem)                        \
                      : "m" (*mem), "ir" (bit));                     \
     __result; })

Definition at line 416 of file atomic.h.

Definition at line 361 of file atomic.h.

Value:
({ unsigned char __result;                                           \
     if (sizeof (*mem) == 1)                                                \
       __asm __volatile (LOCK_PREFIX "decb %b0; sete %1"                    \
                      : "=m" (*mem), "=qm" (__result)                \
                      : "m" (*mem));                                        \
     else if (sizeof (*mem) == 2)                                    \
       __asm __volatile (LOCK_PREFIX "decw %w0; sete %1"                    \
                      : "=m" (*mem), "=qm" (__result)                \
                      : "m" (*mem));                                        \
     else if (sizeof (*mem) == 4)                                    \
       __asm __volatile (LOCK_PREFIX "decl %0; sete %1"                     \
                      : "=m" (*mem), "=qm" (__result)                \
                      : "m" (*mem));                                        \
     else                                                            \
       __asm __volatile (LOCK_PREFIX "decq %q0; sete %1"                    \
                      : "=m" (*mem), "=qm" (__result)                \
                      : "m" (*mem));                                        \
     __result; })

Definition at line 370 of file atomic.h.

#define atomic_delay ( )    asm ("rep; nop")

Definition at line 437 of file atomic.h.

#define atomic_exchange_acq (   mem,
  newvalue 
)
Value:
({ __typeof (*mem) result;                                           \
     if (sizeof (*mem) == 1)                                                \
       __asm __volatile ("xchgb %b0, %1"                             \
                      : "=q" (result), "=m" (*mem)                          \
                      : "0" (newvalue), "m" (*mem));                        \
     else if (sizeof (*mem) == 2)                                    \
       __asm __volatile ("xchgw %w0, %1"                             \
                      : "=r" (result), "=m" (*mem)                          \
                      : "0" (newvalue), "m" (*mem));                        \
     else if (sizeof (*mem) == 4)                                    \
       __asm __volatile ("xchgl %0, %1"                                     \
                      : "=r" (result), "=m" (*mem)                          \
                      : "0" (newvalue), "m" (*mem));                        \
     else                                                            \
       __asm __volatile ("xchgq %q0, %1"                             \
                      : "=r" (result), "=m" (*mem)                          \
                      : "0" ((long) (newvalue)), "m" (*mem));        \
     result; })

Definition at line 143 of file atomic.h.

Definition at line 192 of file atomic.h.

Definition at line 307 of file atomic.h.

Value:
({ unsigned char __result;                                           \
     if (sizeof (*mem) == 1)                                                \
       __asm __volatile (LOCK_PREFIX "incb %b0; sete %1"                    \
                      : "=m" (*mem), "=qm" (__result)                \
                      : "m" (*mem));                                        \
     else if (sizeof (*mem) == 2)                                    \
       __asm __volatile (LOCK_PREFIX "incw %w0; sete %1"                    \
                      : "=m" (*mem), "=qm" (__result)                \
                      : "m" (*mem));                                        \
     else if (sizeof (*mem) == 4)                                    \
       __asm __volatile (LOCK_PREFIX "incl %0; sete %1"                     \
                      : "=m" (*mem), "=qm" (__result)                \
                      : "m" (*mem));                                        \
     else                                                            \
       __asm __volatile (LOCK_PREFIX "incq %q0; sete %1"                    \
                      : "=m" (*mem), "=qm" (__result)                \
                      : "m" (*mem));                                        \
     __result; })

Definition at line 316 of file atomic.h.

#define atomic_or (   mem,
  mask 
)    __arch_or_body (LOCK_PREFIX, mem, mask)

Definition at line 485 of file atomic.h.

#define catomic_add (   mem,
  value 
)    __arch_add_body (__arch_add_cprefix, catomic, mem, value)

Definition at line 237 of file atomic.h.

Definition at line 366 of file atomic.h.

Definition at line 199 of file atomic.h.

Definition at line 312 of file atomic.h.

#define catomic_or (   mem,
  mask 
)    __arch_or_body (__arch_or_cprefix, mem, mask)

Definition at line 490 of file atomic.h.

#define LOCK_PREFIX   "lock;"

Definition at line 54 of file atomic.h.


Typedef Documentation

Definition at line 29 of file atomic.h.

Definition at line 34 of file atomic.h.

Definition at line 39 of file atomic.h.

typedef int8_t atomic8_t

Definition at line 24 of file atomic.h.

Definition at line 31 of file atomic.h.

Definition at line 36 of file atomic.h.

Definition at line 41 of file atomic.h.

Definition at line 26 of file atomic.h.

Definition at line 46 of file atomic.h.

Definition at line 44 of file atomic.h.

Definition at line 30 of file atomic.h.

Definition at line 35 of file atomic.h.

Definition at line 40 of file atomic.h.

Definition at line 25 of file atomic.h.

Definition at line 32 of file atomic.h.

Definition at line 37 of file atomic.h.

Definition at line 42 of file atomic.h.

Definition at line 27 of file atomic.h.

Definition at line 47 of file atomic.h.

Definition at line 45 of file atomic.h.