src/atomic_ops/sysdeps/gcc/x86_64.h

   1 /*
   2  * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.
   3  * Copyright (c) 1996-1999 by Silicon Graphics.  All rights reserved.
   4  * Copyright (c) 1999-2003 by Hewlett-Packard Company. All rights reserved.
   5  *
   6  *
   7  * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
   8  * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
   9  *
  10  * Permission is hereby granted to use or copy this program
  11  * for any purpose,  provided the above notices are retained on all copies.
  12  * Permission to modify the code and to distribute modified code is granted,
  13  * provided the above notices are retained, and a notice that the code was
  14  * modified is included with the above copyright notice.
  15  *
  16  * Some of the machine specific code was borrowed from our GC distribution.
  17  */
  18
  19 #include "../all_aligned_atomic_load_store.h"
  20
  21 /* Real X86 implementations appear                                      */
  22 /* to enforce ordering between memory operations, EXCEPT that a later   */
  23 /* read can pass earlier writes, presumably due to the visible          */
  24 /* presence of store buffers.                                           */
  25 /* We ignore the fact that the official specs                           */
  26 /* seem to be much weaker (and arguably too weak to be usable).         */
  27
  28 #include "../ordered_except_wr.h"
  29
  30 #include "../test_and_set_t_is_char.h"
  31
  32 #include "../standard_ao_double_t.h"
  33
  34 AO_INLINE void
  35 AO_nop_full(void)
  36 {
  37   /* Note: "mfence" (SSE2) is supported on all x86_64/amd64 chips.      */
  38   __asm__ __volatile__("mfence" : : : "memory");
  39 }
  40
  41 #define AO_HAVE_nop_full
  42
  43 /* As far as we can tell, the lfence and sfence instructions are not    */
  44 /* currently needed or useful for cached memory accesses.               */
  45
  46 AO_INLINE AO_t
  47 AO_fetch_and_add_full (volatile AO_t *p, AO_t incr)
  48 {
  49   AO_t result;
  50
  51   __asm__ __volatile__ ("lock; xaddq %0, %1" :
  52                         "=r" (result), "=m" (*p) : "0" (incr), "m" (*p)
  53                         : "memory");
  54   return result;
  55 }
  56
  57 #define AO_HAVE_fetch_and_add_full
  58
  59 AO_INLINE unsigned char
  60 AO_char_fetch_and_add_full (volatile unsigned char *p, unsigned char incr)
  61 {
  62   unsigned char result;
  63
  64   __asm__ __volatile__ ("lock; xaddb %0, %1" :
  65                         "=q" (result), "=m" (*p) : "0" (incr), "m" (*p)
  66                         : "memory");
  67   return result;
  68 }
  69
  70 #define AO_HAVE_char_fetch_and_add_full
  71
  72 AO_INLINE unsigned short
  73 AO_short_fetch_and_add_full (volatile unsigned short *p, unsigned short incr)
  74 {
  75   unsigned short result;
  76
  77   __asm__ __volatile__ ("lock; xaddw %0, %1" :
  78                         "=r" (result), "=m" (*p) : "0" (incr), "m" (*p)
  79                         : "memory");
  80   return result;
  81 }
  82
  83 #define AO_HAVE_short_fetch_and_add_full
  84
  85 AO_INLINE unsigned int
  86 AO_int_fetch_and_add_full (volatile unsigned int *p, unsigned int incr)
  87 {
  88   unsigned int result;
  89
  90   __asm__ __volatile__ ("lock; xaddl %0, %1" :
  91                         "=r" (result), "=m" (*p) : "0" (incr), "m" (*p)
  92                         : "memory");
  93   return result;
  94 }
  95
  96 #define AO_HAVE_int_fetch_and_add_full
  97
  98 AO_INLINE void
  99 AO_or_full (volatile AO_t *p, AO_t incr)
 100 {
 101   __asm__ __volatile__ ("lock; orq %1, %0" :
 102                         "=m" (*p) : "r" (incr), "m" (*p) : "memory");
 103 }
 104
 105 #define AO_HAVE_or_full
 106
 107 AO_INLINE AO_TS_VAL_t
 108 AO_test_and_set_full(volatile AO_TS_t *addr)
 109 {
 110 # ifdef AO_XCHGB_RET_WORD
 111     /* Workaround for a bug in LLVM v2.7 GAS.   */
 112     unsigned oldval;
 113 # else
 114     unsigned char oldval;
 115 # endif
 116   /* Note: the "xchg" instruction does not need a "lock" prefix */
 117   __asm__ __volatile__("xchgb %0, %1"
 118                 : "=q"(oldval), "=m"(*addr)
 119                 : "0"(0xff), "m"(*addr) : "memory");
 120   return (AO_TS_VAL_t)oldval;
 121 }
 122
 123 #define AO_HAVE_test_and_set_full
 124
 125 /* Returns nonzero if the comparison succeeded. */
 126 AO_INLINE int
 127 AO_compare_and_swap_full(volatile AO_t *addr, AO_t old, AO_t new_val)
 128 {
 129 # ifdef AO_USE_SYNC_CAS_BUILTIN
 130     return (int)__sync_bool_compare_and_swap(addr, old, new_val);
 131 # else
 132     char result;
 133     __asm__ __volatile__("lock; cmpxchgq %3, %0; setz %1"
 134                          : "=m" (*addr), "=a" (result)
 135                          : "m" (*addr), "r" (new_val), "a" (old) : "memory");
 136     return (int) result;
 137 # endif
 138 }
 139
 140 #define AO_HAVE_compare_and_swap_full
 141
 142 #ifdef AO_CMPXCHG16B_AVAILABLE
 143 /* NEC LE-IT: older AMD Opterons are missing this instruction.
 144  * On these machines SIGILL will be thrown.
 145  * Define AO_WEAK_DOUBLE_CAS_EMULATION to have an emulated
 146  * (lock based) version available */
 147 /* HB: Changed this to not define either by default.  There are
 148  * enough machines and tool chains around on which cmpxchg16b
 149  * doesn't work.  And the emulation is unsafe by our usual rules.
 150  * Hoewever both are clearly useful in certain cases.
 151  */
 152 AO_INLINE int
 153 AO_compare_double_and_swap_double_full(volatile AO_double_t *addr,
 154                                        AO_t old_val1, AO_t old_val2,
 155                                        AO_t new_val1, AO_t new_val2)
 156 {
 157   char result;
 158   __asm__ __volatile__("lock; cmpxchg16b %0; setz %1"
 159                        : "=m"(*addr), "=a"(result)
 160                        : "m"(*addr), "d" (old_val2), "a" (old_val1),
 161                          "c" (new_val2), "b" (new_val1) : "memory");
 162   return (int) result;
 163 }
 164 #define AO_HAVE_compare_double_and_swap_double_full
 165 #else
 166 /* this one provides spinlock based emulation of CAS implemented in     */
 167 /* atomic_ops.c.  We probably do not want to do this here, since it is  */
 168 /* not atomic with respect to other kinds of updates of *addr.  On the  */
 169 /* other hand, this may be a useful facility on occasion.               */
 170 #ifdef AO_WEAK_DOUBLE_CAS_EMULATION
 171 int AO_compare_double_and_swap_double_emulation(volatile AO_double_t *addr,
 172                                                 AO_t old_val1, AO_t old_val2,
 173                                                 AO_t new_val1, AO_t new_val2);
 174
 175 AO_INLINE int
 176 AO_compare_double_and_swap_double_full(volatile AO_double_t *addr,
 177                                        AO_t old_val1, AO_t old_val2,
 178                                        AO_t new_val1, AO_t new_val2)
 179 {
 180         return AO_compare_double_and_swap_double_emulation(addr,
 181                                                            old_val1, old_val2,
 182                                                            new_val1, new_val2);
 183 }
 184 #define AO_HAVE_compare_double_and_swap_double_full
 185 #endif /* AO_WEAK_DOUBLE_CAS_EMULATION */
 186 #endif /* AO_CMPXCHG16B_AVAILABLE */