helgrind/tests/tc11_XCHG.c

   1
   2 #include "config.h"
   3 #include <pthread.h>
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <assert.h>
   7
   8 /* Simple test program, no race.  Parent and child both modify x and
   9    use the hardware bus lock (implicitly, since XCHG r,m on x86/amd64
  10    does not require an explicit LOCK prefix.). */
  11
  12 #undef PLAT_x86_darwin
  13 #undef PLAT_amd64_darwin
  14 #undef PLAT_x86_freebsd
  15 #undef PLAT_amd64_freebsd
  16 #undef PLAT_arm64_freebsd
  17 #undef PLAT_x86_linux
  18 #undef PLAT_amd64_linux
  19 #undef PLAT_ppc32_linux
  20 #undef PLAT_ppc64be_linux
  21 #undef PLAT_arm_linux
  22 #undef PLAT_s390x_linux
  23 #undef PLAT_mips32_linux
  24 #undef PLAT_x86_solaris
  25 #undef PLAT_amd64_solaris
  26
  27 #if defined(__APPLE__) && defined(__i386__)
  28 #  define PLAT_x86_darwin 1
  29 #elif defined(__APPLE__) && defined(__x86_64__)
  30 #  define PLAT_amd64_darwin 1
  31 #elif defined(__FreeBSD__) && defined(__i386__)
  32 #  define PLAT_x86_freebsd 1
  33 #elif defined(__FreeBSD__) && defined(__amd64__)
  34 #  define PLAT_amd64_freebsd 1
  35 #elif defined(__FreeBSD__) && defined(__aarch64__)
  36 #  define PLAT_arm64_freebsd 1
  37 #elif defined(__linux__) && defined(__i386__)
  38 #  define PLAT_x86_linux 1
  39 #elif defined(__linux__) && defined(__x86_64__)
  40 #  define PLAT_amd64_linux 1
  41 #elif defined(__linux__) && defined(__powerpc__) && !defined(__powerpc64__)
  42 #  define PLAT_ppc32_linux 1
  43 #elif defined(__linux__) && defined(__powerpc__) && defined(__powerpc64__)
  44 #  define PLAT_ppc64_linux 1
  45 #elif defined(__linux__) && defined(__arm__) && !defined(__aarch64__)
  46 #  define PLAT_arm_linux 1
  47 #elif defined(__linux__) && defined(__aarch64__) && !defined(__arm__)
  48 #  define PLAT_arm64_linux 1
  49 #elif defined(__linux__) && defined(__s390x__)
  50 #  define PLAT_s390x_linux 1
  51 #elif defined(__linux__) && defined(__mips__)
  52 #  define PLAT_mips32_linux 1
  53 #elif defined(__linux__) && defined(__nanomips__)
  54 #  define PLAT_nanomips_linux 1
  55 #elif defined(__sun__) && defined(__i386__)
  56 #  define PLAT_x86_solaris 1
  57 #elif defined(__sun__) && defined(__x86_64__)
  58 #  define PLAT_amd64_solaris 1
  59 #endif
  60
  61
  62 #if defined(PLAT_amd64_linux) || defined(PLAT_x86_linux) \
  63     || defined(PLAT_amd64_darwin) || defined(PLAT_x86_darwin) \
  64     || defined(PLAT_amd64_solaris) || defined(PLAT_x86_solaris) \
  65     || defined(PLAT_amd64_freebsd) || defined(PLAT_x86_freebsd)
  66 #  define XCHG_M_R(_addr,_lval) \
  67      __asm__ __volatile__( \
  68         "xchgl %0, %1" \
  69         : /*out*/ "+r"(_lval) \
  70         : /*in*/  "m"(_addr) \
  71         : "memory", "cc" \
  72      )
  73 #  define XCHG_M_R_with_redundant_LOCK(_addr,_lval) \
  74      __asm__ __volatile__( \
  75         "lock xchgl %0, %1" \
  76         : /*out*/ "+r"(_lval) \
  77         : /*in*/  "m"(_addr) \
  78         : "memory", "cc" \
  79      )
  80
  81 #elif defined(PLAT_s390x_linux)
  82 #  define XCHG_M_R(_addr,_lval)                              \
  83      do {                                                    \
  84         __asm__ __volatile__(                                \
  85            "0: l   0,%[global]\n\t"                          \
  86            "   cs  0,%[local],%[global]\n\t"                 \
  87            "   jne 0b\n\t"                                   \
  88            "   lr  %[local],0\n\t"                           \
  89            : /*out*/ [global]"+m"(_addr), [local]"+d"(_lval) \
  90            : /*in*/                                          \
  91            : "0", "memory", "cc"                             \
  92         );                                                   \
  93      } while (0)
  94
  95 #  define XCHG_M_R_with_redundant_LOCK(_addr,_lval) \
  96       XCHG_M_R(_addr,_lval)
  97
  98 #elif defined(PLAT_mips32_linux) || defined(PLAT_mips64_linux)
  99 #  define XCHG_M_R(_addr,_lval)                              \
 100      __asm__ __volatile__(                                   \
 101         "move $12, %2\n"                                     \
 102         "move $13, %1\n"                                     \
 103         "ll $14, 0($13)\n"                                   \
 104         "sc $12, 0($13)\n"                                   \
 105         "move %0, $14\n"                                     \
 106         : /*out*/ "=r"(_lval)                                \
 107         : /*in*/  "r"(&_addr), "r"(_lval)                    \
 108         : "$12", "$13", "$14", "memory", "cc"                \
 109      )
 110
 111 #  define XCHG_M_R_with_redundant_LOCK(_addr,_lval) \
 112       XCHG_M_R(_addr,_lval)
 113 #elif defined(PLAT_nanomips_linux)
 114 #  define XCHG_M_R(_addr,_lval)                              \
 115      __asm__ __volatile__(                                   \
 116         "move $t0, %2\n"                                     \
 117         "move $t1, %1\n"                                     \
 118         "ll $t2, 0($t1)\n"                                   \
 119         "sc $t0, 0($t1)\n"                                   \
 120         "move %0, $t2\n"                                     \
 121         : /*out*/ "=r"(_lval)                                \
 122         : /*in*/  "r"(&_addr), "r"(_lval)                    \
 123         : "$t0", "$t1", "$t1", "memory"                      \
 124      )
 125
 126 #  define XCHG_M_R_with_redundant_LOCK(_addr,_lval) \
 127       XCHG_M_R(_addr,_lval)
 128
 129 #elif defined(PLAT_ppc32_linux) || defined(PLAT_ppc64_linux) \
 130       || defined(PLAT_arm_linux) || defined(PLAT_arm64_linux) \
 131       || defined(PLAT_arm64_freebsd)
 132 #  if defined(HAVE_BUILTIN_ATOMIC)
 133 #    define XCHG_M_R(_addr,_lval)                                           \
 134         do {                                                                \
 135           int tmp;                                                          \
 136           while ((tmp = *(int*)(& _addr)),                                  \
 137                  ! __sync_bool_compare_and_swap((int*)&_addr, tmp, _lval))  \
 138             ;                                                               \
 139           _lval = tmp;                                                      \
 140         } while (0)
 141 #  else
 142 #    warning "XCHG_M_R() implementation is missing. Either" \
 143              "provide one or use a newer gcc version."
 144 #    define XCHG_M_R(_addr,_lval) \
 145         do { int tmp = *(int*)(& _addr); \
 146              *(int*)(& _addr) = (_lval); \
 147              _lval = tmp; \
 148         } while (0)
 149 #  endif
 150 #  define XCHG_M_R_with_redundant_LOCK(_addr,_lval) \
 151       XCHG_M_R(_addr,_lval)
 152
 153 #else
 154 #  error "Unsupported architecture"
 155
 156 #endif
 157
 158 int x = 0;
 159
 160 void* child_fn ( void* arg )
 161 {
 162    int v = 12345;
 163    XCHG_M_R_with_redundant_LOCK(x, v);
 164    assert(v == 0 || v == 6789);
 165    return NULL;
 166 }
 167
 168 int main ( void )
 169 {
 170    int v = 6789;
 171    pthread_t child;
 172
 173    if (pthread_create(&child, NULL, child_fn, NULL)) {
 174       perror("pthread_create");
 175       exit(1);
 176    }
 177
 178    XCHG_M_R(x, v);
 179    assert(v == 0 || v == 12345);
 180
 181    if (pthread_join(child, NULL)) {
 182       perror("pthread join");
 183       exit(1);
 184    }
 185
 186    if (v == 0 || v == 12345)
 187       printf("success\n");
 188    else
 189       printf("failure\n");
 190
 191    return v;
 192 }