src/mm/boehm-gc/libatomic_ops-1.2/src/atomic_ops/generalize-small.h

   1 /* char_load */
   2 #if defined(AO_HAVE_char_load_acquire) && !defined(AO_HAVE_char_load)
   3 #  define AO_char_load(addr) AO_char_load_acquire(addr)
   4 #  define AO_HAVE_char_load
   5 #endif
   6
   7 #if defined(AO_HAVE_char_load_full) && !defined(AO_HAVE_char_load_acquire)
   8 #  define AO_char_load_acquire(addr) AO_char_load_full(addr)
   9 #  define AO_HAVE_char_load_acquire
  10 #endif
  11
  12 #if defined(AO_HAVE_char_load_full) && !defined(AO_HAVE_char_load_read)
  13 #  define AO_char_load_read(addr) AO_char_load_full(addr)
  14 #  define AO_HAVE_char_load_read
  15 #endif
  16
  17 #if !defined(AO_HAVE_char_load_acquire_read) && defined(AO_HAVE_char_load_acquire)
  18 #  define AO_char_load_acquire_read(addr) AO_char_load_acquire(addr)
  19 #  define AO_HAVE_char_load_acquire_read
  20 #endif
  21
  22 #if defined(AO_HAVE_char_load) && defined(AO_HAVE_nop_full) && \
  23     !defined(AO_HAVE_char_load_acquire)
  24    AO_INLINE unsigned char
  25    AO_char_load_acquire(const volatile unsigned char *addr)
  26    {
  27      unsigned char result = AO_char_load(addr);
  28      /* Acquire barrier would be useless, since the load could be delayed  */
  29      /* beyond it.                                                         */
  30      AO_nop_full();
  31      return result;
  32    }
  33 #  define AO_HAVE_char_load_acquire
  34 #endif
  35
  36 #if defined(AO_HAVE_char_load) && defined(AO_HAVE_nop_read) && \
  37     !defined(AO_HAVE_char_load_read)
  38    AO_INLINE unsigned char
  39    AO_char_load_read(const volatile unsigned char *addr)
  40    {
  41      unsigned char result = AO_char_load(addr);
  42      /* Acquire barrier would be useless, since the load could be delayed  */
  43      /* beyond it.                                                         */
  44      AO_nop_read();
  45      return result;
  46    }
  47 #  define AO_HAVE_char_load_read
  48 #endif
  49
  50 #if defined(AO_HAVE_char_load_acquire) && defined(AO_HAVE_nop_full) && \
  51     !defined(AO_HAVE_char_load_full)
  52 #  define AO_char_load_full(addr) (AO_nop_full(), AO_char_load_acquire(addr))
  53 #  define AO_HAVE_char_load_full
  54 #endif
  55
  56 #if !defined(AO_HAVE_char_load_acquire_read) && defined(AO_HAVE_char_load_read)
  57 #  define AO_char_load_acquire_read(addr) AO_char_load_read(addr)
  58 #  define AO_HAVE_char_load_acquire_read
  59 #endif
  60
  61 #if defined(AO_HAVE_char_load_acquire_read) && !defined(AO_HAVE_char_load)
  62 #  define AO_char_load(addr) AO_char_load_acquire_read(addr)
  63 #  define AO_HAVE_char_load
  64 #endif
  65
  66 #ifdef AO_NO_DD_ORDERING
  67 #  if defined(AO_HAVE_char_load_acquire_read)
  68 #    define AO_char_load_dd_acquire_read(addr) \
  69         AO_char_load_acquire_read(addr)
  70 #    define AO_HAVE_char_load_dd_acquire_read
  71 #  endif
  72 #else
  73 #  if defined(AO_HAVE_char_load)
  74 #    define AO_char_load_dd_acquire_read(addr) \
  75         AO_char_load(addr)
  76 #    define AO_HAVE_char_load_dd_acquire_read
  77 #  endif
  78 #endif
  79
  80
  81 /* char_store */
  82
  83 #if defined(AO_HAVE_char_store_release) && !defined(AO_HAVE_char_store)
  84 #  define AO_char_store(addr, val) AO_char_store_release(addr,val)
  85 #  define AO_HAVE_char_store
  86 #endif
  87
  88 #if defined(AO_HAVE_char_store_full) && !defined(AO_HAVE_char_store_release)
  89 #  define AO_char_store_release(addr,val) AO_char_store_full(addr,val)
  90 #  define AO_HAVE_char_store_release
  91 #endif
  92
  93 #if defined(AO_HAVE_char_store_full) && !defined(AO_HAVE_char_store_write)
  94 #  define AO_char_store_write(addr,val) AO_char_store_full(addr,val)
  95 #  define AO_HAVE_char_store_write
  96 #endif
  97
  98 #if defined(AO_HAVE_char_store_release) && \
  99         !defined(AO_HAVE_char_store_release_write)
 100 #  define AO_char_store_release_write(addr, val) \
 101         AO_char_store_release(addr,val)
 102 #  define AO_HAVE_char_store_release_write
 103 #endif
 104
 105 #if defined(AO_HAVE_char_store_write) && !defined(AO_HAVE_char_store)
 106 #  define AO_char_store(addr, val) AO_char_store_write(addr,val)
 107 #  define AO_HAVE_char_store
 108 #endif
 109
 110 #if defined(AO_HAVE_char_store) && defined(AO_HAVE_nop_full) && \
 111     !defined(AO_HAVE_char_store_release)
 112 #  define AO_char_store_release(addr,val) \
 113         (AO_nop_full(), AO_char_store(addr,val))
 114 #  define AO_HAVE_char_store_release
 115 #endif
 116
 117 #if defined(AO_HAVE_nop_write) && defined(AO_HAVE_char_store) && \
 118      !defined(AO_HAVE_char_store_write)
 119 #  define AO_char_store_write(addr, val) \
 120         (AO_nop_write(), AO_char_store(addr,val))
 121 #  define AO_HAVE_char_store_write
 122 #endif
 123
 124 #if defined(AO_HAVE_char_store_write) && \
 125      !defined(AO_HAVE_char_store_release_write)
 126 #  define AO_char_store_release_write(addr, val) AO_char_store_write(addr,val)
 127 #  define AO_HAVE_char_store_release_write
 128 #endif
 129
 130 #if defined(AO_HAVE_char_store_release) && defined(AO_HAVE_nop_full) && \
 131     !defined(AO_HAVE_char_store_full)
 132 #  define AO_char_store_full(addr, val) \
 133         (AO_char_store_release(addr, val), AO_nop_full())
 134 #  define AO_HAVE_char_store_full
 135 #endif
 136
 137
 138 /* char_fetch_and_add */
 139 #if defined(AO_HAVE_char_compare_and_swap_full) && \
 140     !defined(AO_HAVE_char_fetch_and_add_full)
 141    AO_INLINE AO_t
 142    AO_char_fetch_and_add_full(volatile unsigned char *addr,
 143                                unsigned char incr)
 144    {
 145      unsigned char old;
 146      do
 147        {
 148          old = *addr;
 149        }
 150      while (!AO_char_compare_and_swap_full(addr, old, old+incr));
 151      return old;
 152    }
 153 #  define AO_HAVE_char_fetch_and_add_full
 154 #endif
 155
 156 #if defined(AO_HAVE_char_compare_and_swap_acquire) && \
 157     !defined(AO_HAVE_char_fetch_and_add_acquire)
 158    AO_INLINE AO_t
 159    AO_char_fetch_and_add_acquire(volatile unsigned char *addr,
 160                                   unsigned char incr)
 161    {
 162      unsigned char old;
 163      do
 164        {
 165          old = *addr;
 166        }
 167      while (!AO_char_compare_and_swap_acquire(addr, old, old+incr));
 168      return old;
 169    }
 170 #  define AO_HAVE_char_fetch_and_add_acquire
 171 #endif
 172
 173 #if defined(AO_HAVE_char_compare_and_swap_release) && \
 174     !defined(AO_HAVE_char_fetch_and_add_release)
 175    AO_INLINE AO_t
 176    AO_char_fetch_and_add_release(volatile unsigned char *addr,
 177                                   unsigned char incr)
 178    {
 179      unsigned char old;
 180      do
 181        {
 182          old = *addr;
 183        }
 184      while (!AO_char_compare_and_swap_release(addr, old, old+incr));
 185      return old;
 186    }
 187 #  define AO_HAVE_char_fetch_and_add_release
 188 #endif
 189
 190 #if defined(AO_HAVE_char_fetch_and_add_full)
 191 #  if !defined(AO_HAVE_char_fetch_and_add_release)
 192 #    define AO_char_fetch_and_add_release(addr, val) \
 193          AO_char_fetch_and_add_full(addr, val)
 194 #    define AO_HAVE_char_fetch_and_add_release
 195 #  endif
 196 #  if !defined(AO_HAVE_char_fetch_and_add_acquire)
 197 #    define AO_char_fetch_and_add_acquire(addr, val) \
 198          AO_char_fetch_and_add_full(addr, val)
 199 #    define AO_HAVE_char_fetch_and_add_acquire
 200 #  endif
 201 #  if !defined(AO_HAVE_char_fetch_and_add_write)
 202 #    define AO_char_fetch_and_add_write(addr, val) \
 203          AO_char_fetch_and_add_full(addr, val)
 204 #    define AO_HAVE_char_fetch_and_add_write
 205 #  endif
 206 #  if !defined(AO_HAVE_char_fetch_and_add_read)
 207 #    define AO_char_fetch_and_add_read(addr, val) \
 208          AO_char_fetch_and_add_full(addr, val)
 209 #    define AO_HAVE_char_fetch_and_add_read
 210 #  endif
 211 #endif /* AO_HAVE_char_fetch_and_add_full */
 212
 213 #if !defined(AO_HAVE_char_fetch_and_add) && \
 214     defined(AO_HAVE_char_fetch_and_add_release)
 215 #  define AO_char_fetch_and_add(addr, val) \
 216         AO_char_fetch_and_add_release(addr, val)
 217 #  define AO_HAVE_char_fetch_and_add
 218 #endif
 219 #if !defined(AO_HAVE_char_fetch_and_add) && \
 220     defined(AO_HAVE_char_fetch_and_add_acquire)
 221 #  define AO_char_fetch_and_add(addr, val) \
 222         AO_char_fetch_and_add_acquire(addr, val)
 223 #  define AO_HAVE_char_fetch_and_add
 224 #endif
 225 #if !defined(AO_HAVE_char_fetch_and_add) && \
 226     defined(AO_HAVE_char_fetch_and_add_write)
 227 #  define AO_char_fetch_and_add(addr, val) \
 228         AO_char_fetch_and_add_write(addr, val)
 229 #  define AO_HAVE_char_fetch_and_add
 230 #endif
 231 #if !defined(AO_HAVE_char_fetch_and_add) && \
 232     defined(AO_HAVE_char_fetch_and_add_read)
 233 #  define AO_char_fetch_and_add(addr, val) \
 234         AO_char_fetch_and_add_read(addr, val)
 235 #  define AO_HAVE_char_fetch_and_add
 236 #endif
 237
 238 #if defined(AO_HAVE_char_fetch_and_add_acquire) &&\
 239     defined(AO_HAVE_nop_full) && \
 240     !defined(AO_HAVE_char_fetch_and_add_full)
 241 #  define AO_char_fetch_and_add_full(addr, val) \
 242         (AO_nop_full(), AO_char_fetch_and_add_acquire(addr, val))
 243 #endif
 244
 245 #if !defined(AO_HAVE_char_fetch_and_add_release_write) && \
 246     defined(AO_HAVE_char_fetch_and_add_write)
 247 #  define AO_char_fetch_and_add_release_write(addr, val) \
 248         AO_char_fetch_and_add_write(addr, val)
 249 #  define AO_HAVE_char_fetch_and_add_release_write
 250 #endif
 251 #if !defined(AO_HAVE_char_fetch_and_add_release_write) && \
 252     defined(AO_HAVE_char_fetch_and_add_release)
 253 #  define AO_char_fetch_and_add_release_write(addr, val) \
 254         AO_char_fetch_and_add_release(addr, val)
 255 #  define AO_HAVE_char_fetch_and_add_release_write
 256 #endif
 257 #if !defined(AO_HAVE_char_fetch_and_add_acquire_read) && \
 258     defined(AO_HAVE_char_fetch_and_add_read)
 259 #  define AO_char_fetch_and_add_acquire_read(addr, val) \
 260         AO_char_fetch_and_add_read(addr, val)
 261 #  define AO_HAVE_char_fetch_and_add_acquire_read
 262 #endif
 263 #if !defined(AO_HAVE_char_fetch_and_add_acquire_read) && \
 264     defined(AO_HAVE_char_fetch_and_add_acquire)
 265 #  define AO_char_fetch_and_add_acquire_read(addr, val) \
 266         AO_char_fetch_and_add_acquire(addr, val)
 267 #  define AO_HAVE_char_fetch_and_add_acquire_read
 268 #endif
 269
 270 #ifdef AO_NO_DD_ORDERING
 271 #  if defined(AO_HAVE_char_fetch_and_add_acquire_read)
 272 #    define AO_char_fetch_and_add_dd_acquire_read(addr, val) \
 273         AO_char_fetch_and_add_acquire_read(addr, val)
 274 #    define AO_HAVE_char_fetch_and_add_dd_acquire_read
 275 #  endif
 276 #else
 277 #  if defined(AO_HAVE_char_fetch_and_add)
 278 #    define AO_char_fetch_and_add_dd_acquire_read(addr, val) \
 279         AO_char_fetch_and_add(addr, val)
 280 #    define AO_HAVE_char_fetch_and_add_dd_acquire_read
 281 #  endif
 282 #endif
 283
 284 /* char_fetch_and_add1 */
 285
 286 #if defined(AO_HAVE_char_fetch_and_add_full) &&\
 287     !defined(AO_HAVE_char_fetch_and_add1_full)
 288 #  define AO_char_fetch_and_add1_full(addr) \
 289         AO_char_fetch_and_add_full(addr,1)
 290 #  define AO_HAVE_char_fetch_and_add1_full
 291 #endif
 292 #if defined(AO_HAVE_char_fetch_and_add_release) &&\
 293     !defined(AO_HAVE_char_fetch_and_add1_release)
 294 #  define AO_char_fetch_and_add1_release(addr) \
 295         AO_char_fetch_and_add_release(addr,1)
 296 #  define AO_HAVE_char_fetch_and_add1_release
 297 #endif
 298 #if defined(AO_HAVE_char_fetch_and_add_acquire) &&\
 299     !defined(AO_HAVE_char_fetch_and_add1_acquire)
 300 #  define AO_char_fetch_and_add1_acquire(addr) \
 301         AO_char_fetch_and_add_acquire(addr,1)
 302 #  define AO_HAVE_char_fetch_and_add1_acquire
 303 #endif
 304 #if defined(AO_HAVE_char_fetch_and_add_write) &&\
 305     !defined(AO_HAVE_char_fetch_and_add1_write)
 306 #  define AO_char_fetch_and_add1_write(addr) \
 307         AO_char_fetch_and_add_write(addr,1)
 308 #  define AO_HAVE_char_fetch_and_add1_write
 309 #endif
 310 #if defined(AO_HAVE_char_fetch_and_add_read) &&\
 311     !defined(AO_HAVE_char_fetch_and_add1_read)
 312 #  define AO_char_fetch_and_add1_read(addr) \
 313         AO_char_fetch_and_add_read(addr,1)
 314 #  define AO_HAVE_char_fetch_and_add1_read
 315 #endif
 316 #if defined(AO_HAVE_char_fetch_and_add_release_write) &&\
 317     !defined(AO_HAVE_char_fetch_and_add1_release_write)
 318 #  define AO_char_fetch_and_add1_release_write(addr) \
 319         AO_char_fetch_and_add_release_write(addr,1)
 320 #  define AO_HAVE_char_fetch_and_add1_release_write
 321 #endif
 322 #if defined(AO_HAVE_char_fetch_and_add_acquire_read) &&\
 323     !defined(AO_HAVE_char_fetch_and_add1_acquire_read)
 324 #  define AO_char_fetch_and_add1_acquire_read(addr) \
 325         AO_char_fetch_and_add_acquire_read(addr,1)
 326 #  define AO_HAVE_char_fetch_and_add1_acquire_read
 327 #endif
 328 #if defined(AO_HAVE_char_fetch_and_add) &&\
 329     !defined(AO_HAVE_char_fetch_and_add1)
 330 #  define AO_char_fetch_and_add1(addr) \
 331         AO_char_fetch_and_add(addr,1)
 332 #  define AO_HAVE_char_fetch_and_add1
 333 #endif
 334
 335 #if defined(AO_HAVE_char_fetch_and_add1_full)
 336 #  if !defined(AO_HAVE_char_fetch_and_add1_release)
 337 #    define AO_char_fetch_and_add1_release(addr) \
 338          AO_char_fetch_and_add1_full(addr)
 339 #    define AO_HAVE_char_fetch_and_add1_release
 340 #  endif
 341 #  if !defined(AO_HAVE_char_fetch_and_add1_acquire)
 342 #    define AO_char_fetch_and_add1_acquire(addr) \
 343          AO_char_fetch_and_add1_full(addr)
 344 #    define AO_HAVE_char_fetch_and_add1_acquire
 345 #  endif
 346 #  if !defined(AO_HAVE_char_fetch_and_add1_write)
 347 #    define AO_char_fetch_and_add1_write(addr) \
 348          AO_char_fetch_and_add1_full(addr)
 349 #    define AO_HAVE_char_fetch_and_add1_write
 350 #  endif
 351 #  if !defined(AO_HAVE_char_fetch_and_add1_read)
 352 #    define AO_char_fetch_and_add1_read(addr) \
 353          AO_char_fetch_and_add1_full(addr)
 354 #    define AO_HAVE_char_fetch_and_add1_read
 355 #  endif
 356 #endif /* AO_HAVE_char_fetch_and_add1_full */
 357
 358 #if !defined(AO_HAVE_char_fetch_and_add1) && \
 359     defined(AO_HAVE_char_fetch_and_add1_release)
 360 #  define AO_char_fetch_and_add1(addr) \
 361         AO_char_fetch_and_add1_release(addr)
 362 #  define AO_HAVE_char_fetch_and_add1
 363 #endif
 364 #if !defined(AO_HAVE_char_fetch_and_add1) && \
 365     defined(AO_HAVE_char_fetch_and_add1_acquire)
 366 #  define AO_char_fetch_and_add1(addr) \
 367         AO_char_fetch_and_add1_acquire(addr)
 368 #  define AO_HAVE_char_fetch_and_add1
 369 #endif
 370 #if !defined(AO_HAVE_char_fetch_and_add1) && \
 371     defined(AO_HAVE_char_fetch_and_add1_write)
 372 #  define AO_char_fetch_and_add1(addr) \
 373         AO_char_fetch_and_add1_write(addr)
 374 #  define AO_HAVE_char_fetch_and_add1
 375 #endif
 376 #if !defined(AO_HAVE_char_fetch_and_add1) && \
 377     defined(AO_HAVE_char_fetch_and_add1_read)
 378 #  define AO_char_fetch_and_add1(addr) \
 379         AO_char_fetch_and_add1_read(addr)
 380 #  define AO_HAVE_char_fetch_and_add1
 381 #endif
 382
 383 #if defined(AO_HAVE_char_fetch_and_add1_acquire) &&\
 384     defined(AO_HAVE_nop_full) && \
 385     !defined(AO_HAVE_char_fetch_and_add1_full)
 386 #  define AO_char_fetch_and_add1_full(addr) \
 387         (AO_nop_full(), AO_char_fetch_and_add1_acquire(addr))
 388 #  define AO_HAVE_char_fetch_and_add1_full
 389 #endif
 390
 391 #if !defined(AO_HAVE_char_fetch_and_add1_release_write) && \
 392     defined(AO_HAVE_char_fetch_and_add1_write)
 393 #  define AO_char_fetch_and_add1_release_write(addr) \
 394         AO_char_fetch_and_add1_write(addr)
 395 #  define AO_HAVE_char_fetch_and_add1_release_write
 396 #endif
 397 #if !defined(AO_HAVE_char_fetch_and_add1_release_write) && \
 398     defined(AO_HAVE_char_fetch_and_add1_release)
 399 #  define AO_char_fetch_and_add1_release_write(addr) \
 400         AO_char_fetch_and_add1_release(addr)
 401 #  define AO_HAVE_char_fetch_and_add1_release_write
 402 #endif
 403 #if !defined(AO_HAVE_char_fetch_and_add1_acquire_read) && \
 404     defined(AO_HAVE_char_fetch_and_add1_read)
 405 #  define AO_char_fetch_and_add1_acquire_read(addr) \
 406         AO_char_fetch_and_add1_read(addr)
 407 #  define AO_HAVE_char_fetch_and_add1_acquire_read
 408 #endif
 409 #if !defined(AO_HAVE_char_fetch_and_add1_acquire_read) && \
 410     defined(AO_HAVE_char_fetch_and_add1_acquire)
 411 #  define AO_char_fetch_and_add1_acquire_read(addr) \
 412         AO_char_fetch_and_add1_acquire(addr)
 413 #  define AO_HAVE_char_fetch_and_add1_acquire_read
 414 #endif
 415
 416 #ifdef AO_NO_DD_ORDERING
 417 #  if defined(AO_HAVE_char_fetch_and_add1_acquire_read)
 418 #    define AO_char_fetch_and_add1_dd_acquire_read(addr) \
 419         AO_char_fetch_and_add1_acquire_read(addr)
 420 #    define AO_HAVE_char_fetch_and_add1_dd_acquire_read
 421 #  endif
 422 #else
 423 #  if defined(AO_HAVE_char_fetch_and_add1)
 424 #    define AO_char_fetch_and_add1_dd_acquire_read(addr) \
 425         AO_char_fetch_and_add1(addr)
 426 #    define AO_HAVE_char_fetch_and_add1_dd_acquire_read
 427 #  endif
 428 #endif
 429
 430 /* char_fetch_and_sub1 */
 431
 432 #if defined(AO_HAVE_char_fetch_and_add_full) &&\
 433     !defined(AO_HAVE_char_fetch_and_sub1_full)
 434 #  define AO_char_fetch_and_sub1_full(addr) \
 435         AO_char_fetch_and_add_full(addr,(unsigned char)(-1))
 436 #  define AO_HAVE_char_fetch_and_sub1_full
 437 #endif
 438 #if defined(AO_HAVE_char_fetch_and_add_release) &&\
 439     !defined(AO_HAVE_char_fetch_and_sub1_release)
 440 #  define AO_char_fetch_and_sub1_release(addr) \
 441         AO_char_fetch_and_add_release(addr,(unsigned char)(-1))
 442 #  define AO_HAVE_char_fetch_and_sub1_release
 443 #endif
 444 #if defined(AO_HAVE_char_fetch_and_add_acquire) &&\
 445     !defined(AO_HAVE_char_fetch_and_sub1_acquire)
 446 #  define AO_char_fetch_and_sub1_acquire(addr) \
 447         AO_char_fetch_and_add_acquire(addr,(unsigned char)(-1))
 448 #  define AO_HAVE_char_fetch_and_sub1_acquire
 449 #endif
 450 #if defined(AO_HAVE_char_fetch_and_add_write) &&\
 451     !defined(AO_HAVE_char_fetch_and_sub1_write)
 452 #  define AO_char_fetch_and_sub1_write(addr) \
 453         AO_char_fetch_and_add_write(addr,(unsigned char)(-1))
 454 #  define AO_HAVE_char_fetch_and_sub1_write
 455 #endif
 456 #if defined(AO_HAVE_char_fetch_and_add_read) &&\
 457     !defined(AO_HAVE_char_fetch_and_sub1_read)
 458 #  define AO_char_fetch_and_sub1_read(addr) \
 459         AO_char_fetch_and_add_read(addr,(unsigned char)(-1))
 460 #  define AO_HAVE_char_fetch_and_sub1_read
 461 #endif
 462 #if defined(AO_HAVE_char_fetch_and_add_release_write) &&\
 463     !defined(AO_HAVE_char_fetch_and_sub1_release_write)
 464 #  define AO_char_fetch_and_sub1_release_write(addr) \
 465         AO_char_fetch_and_add_release_write(addr,(unsigned char)(-1))
 466 #  define AO_HAVE_char_fetch_and_sub1_release_write
 467 #endif
 468 #if defined(AO_HAVE_char_fetch_and_add_acquire_read) &&\
 469     !defined(AO_HAVE_char_fetch_and_sub1_acquire_read)
 470 #  define AO_char_fetch_and_sub1_acquire_read(addr) \
 471         AO_char_fetch_and_add_acquire_read(addr,(unsigned char)(-1))
 472 #  define AO_HAVE_char_fetch_and_sub1_acquire_read
 473 #endif
 474 #if defined(AO_HAVE_char_fetch_and_add) &&\
 475     !defined(AO_HAVE_char_fetch_and_sub1)
 476 #  define AO_char_fetch_and_sub1(addr) \
 477         AO_char_fetch_and_add(addr,(unsigned char)(-1))
 478 #  define AO_HAVE_char_fetch_and_sub1
 479 #endif
 480
 481 #if defined(AO_HAVE_char_fetch_and_sub1_full)
 482 #  if !defined(AO_HAVE_char_fetch_and_sub1_release)
 483 #    define AO_char_fetch_and_sub1_release(addr) \
 484          AO_char_fetch_and_sub1_full(addr)
 485 #    define AO_HAVE_char_fetch_and_sub1_release
 486 #  endif
 487 #  if !defined(AO_HAVE_char_fetch_and_sub1_acquire)
 488 #    define AO_char_fetch_and_sub1_acquire(addr) \
 489          AO_char_fetch_and_sub1_full(addr)
 490 #    define AO_HAVE_char_fetch_and_sub1_acquire
 491 #  endif
 492 #  if !defined(AO_HAVE_char_fetch_and_sub1_write)
 493 #    define AO_char_fetch_and_sub1_write(addr) \
 494          AO_char_fetch_and_sub1_full(addr)
 495 #    define AO_HAVE_char_fetch_and_sub1_write
 496 #  endif
 497 #  if !defined(AO_HAVE_char_fetch_and_sub1_read)
 498 #    define AO_char_fetch_and_sub1_read(addr) \
 499          AO_char_fetch_and_sub1_full(addr)
 500 #    define AO_HAVE_char_fetch_and_sub1_read
 501 #  endif
 502 #endif /* AO_HAVE_char_fetch_and_sub1_full */
 503
 504 #if !defined(AO_HAVE_char_fetch_and_sub1) && \
 505     defined(AO_HAVE_char_fetch_and_sub1_release)
 506 #  define AO_char_fetch_and_sub1(addr) \
 507         AO_char_fetch_and_sub1_release(addr)
 508 #  define AO_HAVE_char_fetch_and_sub1
 509 #endif
 510 #if !defined(AO_HAVE_char_fetch_and_sub1) && \
 511     defined(AO_HAVE_char_fetch_and_sub1_acquire)
 512 #  define AO_char_fetch_and_sub1(addr) \
 513         AO_char_fetch_and_sub1_acquire(addr)
 514 #  define AO_HAVE_char_fetch_and_sub1
 515 #endif
 516 #if !defined(AO_HAVE_char_fetch_and_sub1) && \
 517     defined(AO_HAVE_char_fetch_and_sub1_write)
 518 #  define AO_char_fetch_and_sub1(addr) \
 519         AO_char_fetch_and_sub1_write(addr)
 520 #  define AO_HAVE_char_fetch_and_sub1
 521 #endif
 522 #if !defined(AO_HAVE_char_fetch_and_sub1) && \
 523     defined(AO_HAVE_char_fetch_and_sub1_read)
 524 #  define AO_char_fetch_and_sub1(addr) \
 525         AO_char_fetch_and_sub1_read(addr)
 526 #  define AO_HAVE_char_fetch_and_sub1
 527 #endif
 528
 529 #if defined(AO_HAVE_char_fetch_and_sub1_acquire) &&\
 530     defined(AO_HAVE_nop_full) && \
 531     !defined(AO_HAVE_char_fetch_and_sub1_full)
 532 #  define AO_char_fetch_and_sub1_full(addr) \
 533         (AO_nop_full(), AO_char_fetch_and_sub1_acquire(addr))
 534 #  define AO_HAVE_char_fetch_and_sub1_full
 535 #endif
 536
 537 #if !defined(AO_HAVE_char_fetch_and_sub1_release_write) && \
 538     defined(AO_HAVE_char_fetch_and_sub1_write)
 539 #  define AO_char_fetch_and_sub1_release_write(addr) \
 540         AO_char_fetch_and_sub1_write(addr)
 541 #  define AO_HAVE_char_fetch_and_sub1_release_write
 542 #endif
 543 #if !defined(AO_HAVE_char_fetch_and_sub1_release_write) && \
 544     defined(AO_HAVE_char_fetch_and_sub1_release)
 545 #  define AO_char_fetch_and_sub1_release_write(addr) \
 546         AO_char_fetch_and_sub1_release(addr)
 547 #  define AO_HAVE_char_fetch_and_sub1_release_write
 548 #endif
 549 #if !defined(AO_HAVE_char_fetch_and_sub1_acquire_read) && \
 550     defined(AO_HAVE_char_fetch_and_sub1_read)
 551 #  define AO_char_fetch_and_sub1_acquire_read(addr) \
 552         AO_char_fetch_and_sub1_read(addr)
 553 #  define AO_HAVE_char_fetch_and_sub1_acquire_read
 554 #endif
 555 #if !defined(AO_HAVE_char_fetch_and_sub1_acquire_read) && \
 556     defined(AO_HAVE_char_fetch_and_sub1_acquire)
 557 #  define AO_char_fetch_and_sub1_acquire_read(addr) \
 558         AO_char_fetch_and_sub1_acquire(addr)
 559 #  define AO_HAVE_char_fetch_and_sub1_acquire_read
 560 #endif
 561
 562 #ifdef AO_NO_DD_ORDERING
 563 #  if defined(AO_HAVE_char_fetch_and_sub1_acquire_read)
 564 #    define AO_char_fetch_and_sub1_dd_acquire_read(addr) \
 565         AO_char_fetch_and_sub1_acquire_read(addr)
 566 #    define AO_HAVE_char_fetch_and_sub1_dd_acquire_read
 567 #  endif
 568 #else
 569 #  if defined(AO_HAVE_char_fetch_and_sub1)
 570 #    define AO_char_fetch_and_sub1_dd_acquire_read(addr) \
 571         AO_char_fetch_and_sub1(addr)
 572 #    define AO_HAVE_char_fetch_and_sub1_dd_acquire_read
 573 #  endif
 574 #endif
 575
 576 /* short_load */
 577 #if defined(AO_HAVE_short_load_acquire) && !defined(AO_HAVE_short_load)
 578 #  define AO_short_load(addr) AO_short_load_acquire(addr)
 579 #  define AO_HAVE_short_load
 580 #endif
 581
 582 #if defined(AO_HAVE_short_load_full) && !defined(AO_HAVE_short_load_acquire)
 583 #  define AO_short_load_acquire(addr) AO_short_load_full(addr)
 584 #  define AO_HAVE_short_load_acquire
 585 #endif
 586
 587 #if defined(AO_HAVE_short_load_full) && !defined(AO_HAVE_short_load_read)
 588 #  define AO_short_load_read(addr) AO_short_load_full(addr)
 589 #  define AO_HAVE_short_load_read
 590 #endif
 591
 592 #if !defined(AO_HAVE_short_load_acquire_read) && defined(AO_HAVE_short_load_acquire)
 593 #  define AO_short_load_acquire_read(addr) AO_short_load_acquire(addr)
 594 #  define AO_HAVE_short_load_acquire_read
 595 #endif
 596
 597 #if defined(AO_HAVE_short_load) && defined(AO_HAVE_nop_full) && \
 598     !defined(AO_HAVE_short_load_acquire)
 599    AO_INLINE unsigned short
 600    AO_short_load_acquire(const volatile unsigned short *addr)
 601    {
 602      unsigned short result = AO_short_load(addr);
 603      /* Acquire barrier would be useless, since the load could be delayed  */
 604      /* beyond it.                                                         */
 605      AO_nop_full();
 606      return result;
 607    }
 608 #  define AO_HAVE_short_load_acquire
 609 #endif
 610
 611 #if defined(AO_HAVE_short_load) && defined(AO_HAVE_nop_read) && \
 612     !defined(AO_HAVE_short_load_read)
 613    AO_INLINE unsigned short
 614    AO_short_load_read(const volatile unsigned short *addr)
 615    {
 616      unsigned short result = AO_short_load(addr);
 617      /* Acquire barrier would be useless, since the load could be delayed  */
 618      /* beyond it.                                                         */
 619      AO_nop_read();
 620      return result;
 621    }
 622 #  define AO_HAVE_short_load_read
 623 #endif
 624
 625 #if defined(AO_HAVE_short_load_acquire) && defined(AO_HAVE_nop_full) && \
 626     !defined(AO_HAVE_short_load_full)
 627 #  define AO_short_load_full(addr) (AO_nop_full(), AO_short_load_acquire(addr))
 628 #  define AO_HAVE_short_load_full
 629 #endif
 630
 631 #if !defined(AO_HAVE_short_load_acquire_read) && defined(AO_HAVE_short_load_read)
 632 #  define AO_short_load_acquire_read(addr) AO_short_load_read(addr)
 633 #  define AO_HAVE_short_load_acquire_read
 634 #endif
 635
 636 #if defined(AO_HAVE_short_load_acquire_read) && !defined(AO_HAVE_short_load)
 637 #  define AO_short_load(addr) AO_short_load_acquire_read(addr)
 638 #  define AO_HAVE_short_load
 639 #endif
 640
 641 #ifdef AO_NO_DD_ORDERING
 642 #  if defined(AO_HAVE_short_load_acquire_read)
 643 #    define AO_short_load_dd_acquire_read(addr) \
 644         AO_short_load_acquire_read(addr)
 645 #    define AO_HAVE_short_load_dd_acquire_read
 646 #  endif
 647 #else
 648 #  if defined(AO_HAVE_short_load)
 649 #    define AO_short_load_dd_acquire_read(addr) \
 650         AO_short_load(addr)
 651 #    define AO_HAVE_short_load_dd_acquire_read
 652 #  endif
 653 #endif
 654
 655
 656 /* short_store */
 657
 658 #if defined(AO_HAVE_short_store_release) && !defined(AO_HAVE_short_store)
 659 #  define AO_short_store(addr, val) AO_short_store_release(addr,val)
 660 #  define AO_HAVE_short_store
 661 #endif
 662
 663 #if defined(AO_HAVE_short_store_full) && !defined(AO_HAVE_short_store_release)
 664 #  define AO_short_store_release(addr,val) AO_short_store_full(addr,val)
 665 #  define AO_HAVE_short_store_release
 666 #endif
 667
 668 #if defined(AO_HAVE_short_store_full) && !defined(AO_HAVE_short_store_write)
 669 #  define AO_short_store_write(addr,val) AO_short_store_full(addr,val)
 670 #  define AO_HAVE_short_store_write
 671 #endif
 672
 673 #if defined(AO_HAVE_short_store_release) && \
 674         !defined(AO_HAVE_short_store_release_write)
 675 #  define AO_short_store_release_write(addr, val) \
 676         AO_short_store_release(addr,val)
 677 #  define AO_HAVE_short_store_release_write
 678 #endif
 679
 680 #if defined(AO_HAVE_short_store_write) && !defined(AO_HAVE_short_store)
 681 #  define AO_short_store(addr, val) AO_short_store_write(addr,val)
 682 #  define AO_HAVE_short_store
 683 #endif
 684
 685 #if defined(AO_HAVE_short_store) && defined(AO_HAVE_nop_full) && \
 686     !defined(AO_HAVE_short_store_release)
 687 #  define AO_short_store_release(addr,val) \
 688         (AO_nop_full(), AO_short_store(addr,val))
 689 #  define AO_HAVE_short_store_release
 690 #endif
 691
 692 #if defined(AO_HAVE_nop_write) && defined(AO_HAVE_short_store) && \
 693      !defined(AO_HAVE_short_store_write)
 694 #  define AO_short_store_write(addr, val) \
 695         (AO_nop_write(), AO_short_store(addr,val))
 696 #  define AO_HAVE_short_store_write
 697 #endif
 698
 699 #if defined(AO_HAVE_short_store_write) && \
 700      !defined(AO_HAVE_short_store_release_write)
 701 #  define AO_short_store_release_write(addr, val) AO_short_store_write(addr,val)
 702 #  define AO_HAVE_short_store_release_write
 703 #endif
 704
 705 #if defined(AO_HAVE_short_store_release) && defined(AO_HAVE_nop_full) && \
 706     !defined(AO_HAVE_short_store_full)
 707 #  define AO_short_store_full(addr, val) \
 708         (AO_short_store_release(addr, val), AO_nop_full())
 709 #  define AO_HAVE_short_store_full
 710 #endif
 711
 712
 713 /* short_fetch_and_add */
 714 #if defined(AO_HAVE_short_compare_and_swap_full) && \
 715     !defined(AO_HAVE_short_fetch_and_add_full)
 716    AO_INLINE AO_t
 717    AO_short_fetch_and_add_full(volatile unsigned short *addr,
 718                                unsigned short incr)
 719    {
 720      unsigned short old;
 721      do
 722        {
 723          old = *addr;
 724        }
 725      while (!AO_short_compare_and_swap_full(addr, old, old+incr));
 726      return old;
 727    }
 728 #  define AO_HAVE_short_fetch_and_add_full
 729 #endif
 730
 731 #if defined(AO_HAVE_short_compare_and_swap_acquire) && \
 732     !defined(AO_HAVE_short_fetch_and_add_acquire)
 733    AO_INLINE AO_t
 734    AO_short_fetch_and_add_acquire(volatile unsigned short *addr,
 735                                   unsigned short incr)
 736    {
 737      unsigned short old;
 738      do
 739        {
 740          old = *addr;
 741        }
 742      while (!AO_short_compare_and_swap_acquire(addr, old, old+incr));
 743      return old;
 744    }
 745 #  define AO_HAVE_short_fetch_and_add_acquire
 746 #endif
 747
 748 #if defined(AO_HAVE_short_compare_and_swap_release) && \
 749     !defined(AO_HAVE_short_fetch_and_add_release)
 750    AO_INLINE AO_t
 751    AO_short_fetch_and_add_release(volatile unsigned short *addr,
 752                                   unsigned short incr)
 753    {
 754      unsigned short old;
 755      do
 756        {
 757          old = *addr;
 758        }
 759      while (!AO_short_compare_and_swap_release(addr, old, old+incr));
 760      return old;
 761    }
 762 #  define AO_HAVE_short_fetch_and_add_release
 763 #endif
 764
 765 #if defined(AO_HAVE_short_fetch_and_add_full)
 766 #  if !defined(AO_HAVE_short_fetch_and_add_release)
 767 #    define AO_short_fetch_and_add_release(addr, val) \
 768          AO_short_fetch_and_add_full(addr, val)
 769 #    define AO_HAVE_short_fetch_and_add_release
 770 #  endif
 771 #  if !defined(AO_HAVE_short_fetch_and_add_acquire)
 772 #    define AO_short_fetch_and_add_acquire(addr, val) \
 773          AO_short_fetch_and_add_full(addr, val)
 774 #    define AO_HAVE_short_fetch_and_add_acquire
 775 #  endif
 776 #  if !defined(AO_HAVE_short_fetch_and_add_write)
 777 #    define AO_short_fetch_and_add_write(addr, val) \
 778          AO_short_fetch_and_add_full(addr, val)
 779 #    define AO_HAVE_short_fetch_and_add_write
 780 #  endif
 781 #  if !defined(AO_HAVE_short_fetch_and_add_read)
 782 #    define AO_short_fetch_and_add_read(addr, val) \
 783          AO_short_fetch_and_add_full(addr, val)
 784 #    define AO_HAVE_short_fetch_and_add_read
 785 #  endif
 786 #endif /* AO_HAVE_short_fetch_and_add_full */
 787
 788 #if !defined(AO_HAVE_short_fetch_and_add) && \
 789     defined(AO_HAVE_short_fetch_and_add_release)
 790 #  define AO_short_fetch_and_add(addr, val) \
 791         AO_short_fetch_and_add_release(addr, val)
 792 #  define AO_HAVE_short_fetch_and_add
 793 #endif
 794 #if !defined(AO_HAVE_short_fetch_and_add) && \
 795     defined(AO_HAVE_short_fetch_and_add_acquire)
 796 #  define AO_short_fetch_and_add(addr, val) \
 797         AO_short_fetch_and_add_acquire(addr, val)
 798 #  define AO_HAVE_short_fetch_and_add
 799 #endif
 800 #if !defined(AO_HAVE_short_fetch_and_add) && \
 801     defined(AO_HAVE_short_fetch_and_add_write)
 802 #  define AO_short_fetch_and_add(addr, val) \
 803         AO_short_fetch_and_add_write(addr, val)
 804 #  define AO_HAVE_short_fetch_and_add
 805 #endif
 806 #if !defined(AO_HAVE_short_fetch_and_add) && \
 807     defined(AO_HAVE_short_fetch_and_add_read)
 808 #  define AO_short_fetch_and_add(addr, val) \
 809         AO_short_fetch_and_add_read(addr, val)
 810 #  define AO_HAVE_short_fetch_and_add
 811 #endif
 812
 813 #if defined(AO_HAVE_short_fetch_and_add_acquire) &&\
 814     defined(AO_HAVE_nop_full) && \
 815     !defined(AO_HAVE_short_fetch_and_add_full)
 816 #  define AO_short_fetch_and_add_full(addr, val) \
 817         (AO_nop_full(), AO_short_fetch_and_add_acquire(addr, val))
 818 #endif
 819
 820 #if !defined(AO_HAVE_short_fetch_and_add_release_write) && \
 821     defined(AO_HAVE_short_fetch_and_add_write)
 822 #  define AO_short_fetch_and_add_release_write(addr, val) \
 823         AO_short_fetch_and_add_write(addr, val)
 824 #  define AO_HAVE_short_fetch_and_add_release_write
 825 #endif
 826 #if !defined(AO_HAVE_short_fetch_and_add_release_write) && \
 827     defined(AO_HAVE_short_fetch_and_add_release)
 828 #  define AO_short_fetch_and_add_release_write(addr, val) \
 829         AO_short_fetch_and_add_release(addr, val)
 830 #  define AO_HAVE_short_fetch_and_add_release_write
 831 #endif
 832 #if !defined(AO_HAVE_short_fetch_and_add_acquire_read) && \
 833     defined(AO_HAVE_short_fetch_and_add_read)
 834 #  define AO_short_fetch_and_add_acquire_read(addr, val) \
 835         AO_short_fetch_and_add_read(addr, val)
 836 #  define AO_HAVE_short_fetch_and_add_acquire_read
 837 #endif
 838 #if !defined(AO_HAVE_short_fetch_and_add_acquire_read) && \
 839     defined(AO_HAVE_short_fetch_and_add_acquire)
 840 #  define AO_short_fetch_and_add_acquire_read(addr, val) \
 841         AO_short_fetch_and_add_acquire(addr, val)
 842 #  define AO_HAVE_short_fetch_and_add_acquire_read
 843 #endif
 844
 845 #ifdef AO_NO_DD_ORDERING
 846 #  if defined(AO_HAVE_short_fetch_and_add_acquire_read)
 847 #    define AO_short_fetch_and_add_dd_acquire_read(addr, val) \
 848         AO_short_fetch_and_add_acquire_read(addr, val)
 849 #    define AO_HAVE_short_fetch_and_add_dd_acquire_read
 850 #  endif
 851 #else
 852 #  if defined(AO_HAVE_short_fetch_and_add)
 853 #    define AO_short_fetch_and_add_dd_acquire_read(addr, val) \
 854         AO_short_fetch_and_add(addr, val)
 855 #    define AO_HAVE_short_fetch_and_add_dd_acquire_read
 856 #  endif
 857 #endif
 858
 859 /* short_fetch_and_add1 */
 860
 861 #if defined(AO_HAVE_short_fetch_and_add_full) &&\
 862     !defined(AO_HAVE_short_fetch_and_add1_full)
 863 #  define AO_short_fetch_and_add1_full(addr) \
 864         AO_short_fetch_and_add_full(addr,1)
 865 #  define AO_HAVE_short_fetch_and_add1_full
 866 #endif
 867 #if defined(AO_HAVE_short_fetch_and_add_release) &&\
 868     !defined(AO_HAVE_short_fetch_and_add1_release)
 869 #  define AO_short_fetch_and_add1_release(addr) \
 870         AO_short_fetch_and_add_release(addr,1)
 871 #  define AO_HAVE_short_fetch_and_add1_release
 872 #endif
 873 #if defined(AO_HAVE_short_fetch_and_add_acquire) &&\
 874     !defined(AO_HAVE_short_fetch_and_add1_acquire)
 875 #  define AO_short_fetch_and_add1_acquire(addr) \
 876         AO_short_fetch_and_add_acquire(addr,1)
 877 #  define AO_HAVE_short_fetch_and_add1_acquire
 878 #endif
 879 #if defined(AO_HAVE_short_fetch_and_add_write) &&\
 880     !defined(AO_HAVE_short_fetch_and_add1_write)
 881 #  define AO_short_fetch_and_add1_write(addr) \
 882         AO_short_fetch_and_add_write(addr,1)
 883 #  define AO_HAVE_short_fetch_and_add1_write
 884 #endif
 885 #if defined(AO_HAVE_short_fetch_and_add_read) &&\
 886     !defined(AO_HAVE_short_fetch_and_add1_read)
 887 #  define AO_short_fetch_and_add1_read(addr) \
 888         AO_short_fetch_and_add_read(addr,1)
 889 #  define AO_HAVE_short_fetch_and_add1_read
 890 #endif
 891 #if defined(AO_HAVE_short_fetch_and_add_release_write) &&\
 892     !defined(AO_HAVE_short_fetch_and_add1_release_write)
 893 #  define AO_short_fetch_and_add1_release_write(addr) \
 894         AO_short_fetch_and_add_release_write(addr,1)
 895 #  define AO_HAVE_short_fetch_and_add1_release_write
 896 #endif
 897 #if defined(AO_HAVE_short_fetch_and_add_acquire_read) &&\
 898     !defined(AO_HAVE_short_fetch_and_add1_acquire_read)
 899 #  define AO_short_fetch_and_add1_acquire_read(addr) \
 900         AO_short_fetch_and_add_acquire_read(addr,1)
 901 #  define AO_HAVE_short_fetch_and_add1_acquire_read
 902 #endif
 903 #if defined(AO_HAVE_short_fetch_and_add) &&\
 904     !defined(AO_HAVE_short_fetch_and_add1)
 905 #  define AO_short_fetch_and_add1(addr) \
 906         AO_short_fetch_and_add(addr,1)
 907 #  define AO_HAVE_short_fetch_and_add1
 908 #endif
 909
 910 #if defined(AO_HAVE_short_fetch_and_add1_full)
 911 #  if !defined(AO_HAVE_short_fetch_and_add1_release)
 912 #    define AO_short_fetch_and_add1_release(addr) \
 913          AO_short_fetch_and_add1_full(addr)
 914 #    define AO_HAVE_short_fetch_and_add1_release
 915 #  endif
 916 #  if !defined(AO_HAVE_short_fetch_and_add1_acquire)
 917 #    define AO_short_fetch_and_add1_acquire(addr) \
 918          AO_short_fetch_and_add1_full(addr)
 919 #    define AO_HAVE_short_fetch_and_add1_acquire
 920 #  endif
 921 #  if !defined(AO_HAVE_short_fetch_and_add1_write)
 922 #    define AO_short_fetch_and_add1_write(addr) \
 923          AO_short_fetch_and_add1_full(addr)
 924 #    define AO_HAVE_short_fetch_and_add1_write
 925 #  endif
 926 #  if !defined(AO_HAVE_short_fetch_and_add1_read)
 927 #    define AO_short_fetch_and_add1_read(addr) \
 928          AO_short_fetch_and_add1_full(addr)
 929 #    define AO_HAVE_short_fetch_and_add1_read
 930 #  endif
 931 #endif /* AO_HAVE_short_fetch_and_add1_full */
 932
 933 #if !defined(AO_HAVE_short_fetch_and_add1) && \
 934     defined(AO_HAVE_short_fetch_and_add1_release)
 935 #  define AO_short_fetch_and_add1(addr) \
 936         AO_short_fetch_and_add1_release(addr)
 937 #  define AO_HAVE_short_fetch_and_add1
 938 #endif
 939 #if !defined(AO_HAVE_short_fetch_and_add1) && \
 940     defined(AO_HAVE_short_fetch_and_add1_acquire)
 941 #  define AO_short_fetch_and_add1(addr) \
 942         AO_short_fetch_and_add1_acquire(addr)
 943 #  define AO_HAVE_short_fetch_and_add1
 944 #endif
 945 #if !defined(AO_HAVE_short_fetch_and_add1) && \
 946     defined(AO_HAVE_short_fetch_and_add1_write)
 947 #  define AO_short_fetch_and_add1(addr) \
 948         AO_short_fetch_and_add1_write(addr)
 949 #  define AO_HAVE_short_fetch_and_add1
 950 #endif
 951 #if !defined(AO_HAVE_short_fetch_and_add1) && \
 952     defined(AO_HAVE_short_fetch_and_add1_read)
 953 #  define AO_short_fetch_and_add1(addr) \
 954         AO_short_fetch_and_add1_read(addr)
 955 #  define AO_HAVE_short_fetch_and_add1
 956 #endif
 957
 958 #if defined(AO_HAVE_short_fetch_and_add1_acquire) &&\
 959     defined(AO_HAVE_nop_full) && \
 960     !defined(AO_HAVE_short_fetch_and_add1_full)
 961 #  define AO_short_fetch_and_add1_full(addr) \
 962         (AO_nop_full(), AO_short_fetch_and_add1_acquire(addr))
 963 #  define AO_HAVE_short_fetch_and_add1_full
 964 #endif
 965
 966 #if !defined(AO_HAVE_short_fetch_and_add1_release_write) && \
 967     defined(AO_HAVE_short_fetch_and_add1_write)
 968 #  define AO_short_fetch_and_add1_release_write(addr) \
 969         AO_short_fetch_and_add1_write(addr)
 970 #  define AO_HAVE_short_fetch_and_add1_release_write
 971 #endif
 972 #if !defined(AO_HAVE_short_fetch_and_add1_release_write) && \
 973     defined(AO_HAVE_short_fetch_and_add1_release)
 974 #  define AO_short_fetch_and_add1_release_write(addr) \
 975         AO_short_fetch_and_add1_release(addr)
 976 #  define AO_HAVE_short_fetch_and_add1_release_write
 977 #endif
 978 #if !defined(AO_HAVE_short_fetch_and_add1_acquire_read) && \
 979     defined(AO_HAVE_short_fetch_and_add1_read)
 980 #  define AO_short_fetch_and_add1_acquire_read(addr) \
 981         AO_short_fetch_and_add1_read(addr)
 982 #  define AO_HAVE_short_fetch_and_add1_acquire_read
 983 #endif
 984 #if !defined(AO_HAVE_short_fetch_and_add1_acquire_read) && \
 985     defined(AO_HAVE_short_fetch_and_add1_acquire)
 986 #  define AO_short_fetch_and_add1_acquire_read(addr) \
 987         AO_short_fetch_and_add1_acquire(addr)
 988 #  define AO_HAVE_short_fetch_and_add1_acquire_read
 989 #endif
 990
 991 #ifdef AO_NO_DD_ORDERING
 992 #  if defined(AO_HAVE_short_fetch_and_add1_acquire_read)
 993 #    define AO_short_fetch_and_add1_dd_acquire_read(addr) \
 994         AO_short_fetch_and_add1_acquire_read(addr)
 995 #    define AO_HAVE_short_fetch_and_add1_dd_acquire_read
 996 #  endif
 997 #else
 998 #  if defined(AO_HAVE_short_fetch_and_add1)
 999 #    define AO_short_fetch_and_add1_dd_acquire_read(addr) \
1000         AO_short_fetch_and_add1(addr)
1001 #    define AO_HAVE_short_fetch_and_add1_dd_acquire_read
1002 #  endif
1003 #endif
1004
1005 /* short_fetch_and_sub1 */
1006
1007 #if defined(AO_HAVE_short_fetch_and_add_full) &&\
1008     !defined(AO_HAVE_short_fetch_and_sub1_full)
1009 #  define AO_short_fetch_and_sub1_full(addr) \
1010         AO_short_fetch_and_add_full(addr,(unsigned short)(-1))
1011 #  define AO_HAVE_short_fetch_and_sub1_full
1012 #endif
1013 #if defined(AO_HAVE_short_fetch_and_add_release) &&\
1014     !defined(AO_HAVE_short_fetch_and_sub1_release)
1015 #  define AO_short_fetch_and_sub1_release(addr) \
1016         AO_short_fetch_and_add_release(addr,(unsigned short)(-1))
1017 #  define AO_HAVE_short_fetch_and_sub1_release
1018 #endif
1019 #if defined(AO_HAVE_short_fetch_and_add_acquire) &&\
1020     !defined(AO_HAVE_short_fetch_and_sub1_acquire)
1021 #  define AO_short_fetch_and_sub1_acquire(addr) \
1022         AO_short_fetch_and_add_acquire(addr,(unsigned short)(-1))
1023 #  define AO_HAVE_short_fetch_and_sub1_acquire
1024 #endif
1025 #if defined(AO_HAVE_short_fetch_and_add_write) &&\
1026     !defined(AO_HAVE_short_fetch_and_sub1_write)
1027 #  define AO_short_fetch_and_sub1_write(addr) \
1028         AO_short_fetch_and_add_write(addr,(unsigned short)(-1))
1029 #  define AO_HAVE_short_fetch_and_sub1_write
1030 #endif
1031 #if defined(AO_HAVE_short_fetch_and_add_read) &&\
1032     !defined(AO_HAVE_short_fetch_and_sub1_read)
1033 #  define AO_short_fetch_and_sub1_read(addr) \
1034         AO_short_fetch_and_add_read(addr,(unsigned short)(-1))
1035 #  define AO_HAVE_short_fetch_and_sub1_read
1036 #endif
1037 #if defined(AO_HAVE_short_fetch_and_add_release_write) &&\
1038     !defined(AO_HAVE_short_fetch_and_sub1_release_write)
1039 #  define AO_short_fetch_and_sub1_release_write(addr) \
1040         AO_short_fetch_and_add_release_write(addr,(unsigned short)(-1))
1041 #  define AO_HAVE_short_fetch_and_sub1_release_write
1042 #endif
1043 #if defined(AO_HAVE_short_fetch_and_add_acquire_read) &&\
1044     !defined(AO_HAVE_short_fetch_and_sub1_acquire_read)
1045 #  define AO_short_fetch_and_sub1_acquire_read(addr) \
1046         AO_short_fetch_and_add_acquire_read(addr,(unsigned short)(-1))
1047 #  define AO_HAVE_short_fetch_and_sub1_acquire_read
1048 #endif
1049 #if defined(AO_HAVE_short_fetch_and_add) &&\
1050     !defined(AO_HAVE_short_fetch_and_sub1)
1051 #  define AO_short_fetch_and_sub1(addr) \
1052         AO_short_fetch_and_add(addr,(unsigned short)(-1))
1053 #  define AO_HAVE_short_fetch_and_sub1
1054 #endif
1055
1056 #if defined(AO_HAVE_short_fetch_and_sub1_full)
1057 #  if !defined(AO_HAVE_short_fetch_and_sub1_release)
1058 #    define AO_short_fetch_and_sub1_release(addr) \
1059          AO_short_fetch_and_sub1_full(addr)
1060 #    define AO_HAVE_short_fetch_and_sub1_release
1061 #  endif
1062 #  if !defined(AO_HAVE_short_fetch_and_sub1_acquire)
1063 #    define AO_short_fetch_and_sub1_acquire(addr) \
1064          AO_short_fetch_and_sub1_full(addr)
1065 #    define AO_HAVE_short_fetch_and_sub1_acquire
1066 #  endif
1067 #  if !defined(AO_HAVE_short_fetch_and_sub1_write)
1068 #    define AO_short_fetch_and_sub1_write(addr) \
1069          AO_short_fetch_and_sub1_full(addr)
1070 #    define AO_HAVE_short_fetch_and_sub1_write
1071 #  endif
1072 #  if !defined(AO_HAVE_short_fetch_and_sub1_read)
1073 #    define AO_short_fetch_and_sub1_read(addr) \
1074          AO_short_fetch_and_sub1_full(addr)
1075 #    define AO_HAVE_short_fetch_and_sub1_read
1076 #  endif
1077 #endif /* AO_HAVE_short_fetch_and_sub1_full */
1078
1079 #if !defined(AO_HAVE_short_fetch_and_sub1) && \
1080     defined(AO_HAVE_short_fetch_and_sub1_release)
1081 #  define AO_short_fetch_and_sub1(addr) \
1082         AO_short_fetch_and_sub1_release(addr)
1083 #  define AO_HAVE_short_fetch_and_sub1
1084 #endif
1085 #if !defined(AO_HAVE_short_fetch_and_sub1) && \
1086     defined(AO_HAVE_short_fetch_and_sub1_acquire)
1087 #  define AO_short_fetch_and_sub1(addr) \
1088         AO_short_fetch_and_sub1_acquire(addr)
1089 #  define AO_HAVE_short_fetch_and_sub1
1090 #endif
1091 #if !defined(AO_HAVE_short_fetch_and_sub1) && \
1092     defined(AO_HAVE_short_fetch_and_sub1_write)
1093 #  define AO_short_fetch_and_sub1(addr) \
1094         AO_short_fetch_and_sub1_write(addr)
1095 #  define AO_HAVE_short_fetch_and_sub1
1096 #endif
1097 #if !defined(AO_HAVE_short_fetch_and_sub1) && \
1098     defined(AO_HAVE_short_fetch_and_sub1_read)
1099 #  define AO_short_fetch_and_sub1(addr) \
1100         AO_short_fetch_and_sub1_read(addr)
1101 #  define AO_HAVE_short_fetch_and_sub1
1102 #endif
1103
1104 #if defined(AO_HAVE_short_fetch_and_sub1_acquire) &&\
1105     defined(AO_HAVE_nop_full) && \
1106     !defined(AO_HAVE_short_fetch_and_sub1_full)
1107 #  define AO_short_fetch_and_sub1_full(addr) \
1108         (AO_nop_full(), AO_short_fetch_and_sub1_acquire(addr))
1109 #  define AO_HAVE_short_fetch_and_sub1_full
1110 #endif
1111
1112 #if !defined(AO_HAVE_short_fetch_and_sub1_release_write) && \
1113     defined(AO_HAVE_short_fetch_and_sub1_write)
1114 #  define AO_short_fetch_and_sub1_release_write(addr) \
1115         AO_short_fetch_and_sub1_write(addr)
1116 #  define AO_HAVE_short_fetch_and_sub1_release_write
1117 #endif
1118 #if !defined(AO_HAVE_short_fetch_and_sub1_release_write) && \
1119     defined(AO_HAVE_short_fetch_and_sub1_release)
1120 #  define AO_short_fetch_and_sub1_release_write(addr) \
1121         AO_short_fetch_and_sub1_release(addr)
1122 #  define AO_HAVE_short_fetch_and_sub1_release_write
1123 #endif
1124 #if !defined(AO_HAVE_short_fetch_and_sub1_acquire_read) && \
1125     defined(AO_HAVE_short_fetch_and_sub1_read)
1126 #  define AO_short_fetch_and_sub1_acquire_read(addr) \
1127         AO_short_fetch_and_sub1_read(addr)
1128 #  define AO_HAVE_short_fetch_and_sub1_acquire_read
1129 #endif
1130 #if !defined(AO_HAVE_short_fetch_and_sub1_acquire_read) && \
1131     defined(AO_HAVE_short_fetch_and_sub1_acquire)
1132 #  define AO_short_fetch_and_sub1_acquire_read(addr) \
1133         AO_short_fetch_and_sub1_acquire(addr)
1134 #  define AO_HAVE_short_fetch_and_sub1_acquire_read
1135 #endif
1136
1137 #ifdef AO_NO_DD_ORDERING
1138 #  if defined(AO_HAVE_short_fetch_and_sub1_acquire_read)
1139 #    define AO_short_fetch_and_sub1_dd_acquire_read(addr) \
1140         AO_short_fetch_and_sub1_acquire_read(addr)
1141 #    define AO_HAVE_short_fetch_and_sub1_dd_acquire_read
1142 #  endif
1143 #else
1144 #  if defined(AO_HAVE_short_fetch_and_sub1)
1145 #    define AO_short_fetch_and_sub1_dd_acquire_read(addr) \
1146         AO_short_fetch_and_sub1(addr)
1147 #    define AO_HAVE_short_fetch_and_sub1_dd_acquire_read
1148 #  endif
1149 #endif
1150
1151 /* int_load */
1152 #if defined(AO_HAVE_int_load_acquire) && !defined(AO_HAVE_int_load)
1153 #  define AO_int_load(addr) AO_int_load_acquire(addr)
1154 #  define AO_HAVE_int_load
1155 #endif
1156
1157 #if defined(AO_HAVE_int_load_full) && !defined(AO_HAVE_int_load_acquire)
1158 #  define AO_int_load_acquire(addr) AO_int_load_full(addr)
1159 #  define AO_HAVE_int_load_acquire
1160 #endif
1161
1162 #if defined(AO_HAVE_int_load_full) && !defined(AO_HAVE_int_load_read)
1163 #  define AO_int_load_read(addr) AO_int_load_full(addr)
1164 #  define AO_HAVE_int_load_read
1165 #endif
1166
1167 #if !defined(AO_HAVE_int_load_acquire_read) && defined(AO_HAVE_int_load_acquire)
1168 #  define AO_int_load_acquire_read(addr) AO_int_load_acquire(addr)
1169 #  define AO_HAVE_int_load_acquire_read
1170 #endif
1171
1172 #if defined(AO_HAVE_int_load) && defined(AO_HAVE_nop_full) && \
1173     !defined(AO_HAVE_int_load_acquire)
1174    AO_INLINE unsigned int
1175    AO_int_load_acquire(const volatile unsigned int *addr)
1176    {
1177      unsigned int result = AO_int_load(addr);
1178      /* Acquire barrier would be useless, since the load could be delayed  */
1179      /* beyond it.                                                         */
1180      AO_nop_full();
1181      return result;
1182    }
1183 #  define AO_HAVE_int_load_acquire
1184 #endif
1185
1186 #if defined(AO_HAVE_int_load) && defined(AO_HAVE_nop_read) && \
1187     !defined(AO_HAVE_int_load_read)
1188    AO_INLINE unsigned int
1189    AO_int_load_read(const volatile unsigned int *addr)
1190    {
1191      unsigned int result = AO_int_load(addr);
1192      /* Acquire barrier would be useless, since the load could be delayed  */
1193      /* beyond it.                                                         */
1194      AO_nop_read();
1195      return result;
1196    }
1197 #  define AO_HAVE_int_load_read
1198 #endif
1199
1200 #if defined(AO_HAVE_int_load_acquire) && defined(AO_HAVE_nop_full) && \
1201     !defined(AO_HAVE_int_load_full)
1202 #  define AO_int_load_full(addr) (AO_nop_full(), AO_int_load_acquire(addr))
1203 #  define AO_HAVE_int_load_full
1204 #endif
1205
1206 #if !defined(AO_HAVE_int_load_acquire_read) && defined(AO_HAVE_int_load_read)
1207 #  define AO_int_load_acquire_read(addr) AO_int_load_read(addr)
1208 #  define AO_HAVE_int_load_acquire_read
1209 #endif
1210
1211 #if defined(AO_HAVE_int_load_acquire_read) && !defined(AO_HAVE_int_load)
1212 #  define AO_int_load(addr) AO_int_load_acquire_read(addr)
1213 #  define AO_HAVE_int_load
1214 #endif
1215
1216 #ifdef AO_NO_DD_ORDERING
1217 #  if defined(AO_HAVE_int_load_acquire_read)
1218 #    define AO_int_load_dd_acquire_read(addr) \
1219         AO_int_load_acquire_read(addr)
1220 #    define AO_HAVE_int_load_dd_acquire_read
1221 #  endif
1222 #else
1223 #  if defined(AO_HAVE_int_load)
1224 #    define AO_int_load_dd_acquire_read(addr) \
1225         AO_int_load(addr)
1226 #    define AO_HAVE_int_load_dd_acquire_read
1227 #  endif
1228 #endif
1229
1230
1231 /* int_store */
1232
1233 #if defined(AO_HAVE_int_store_release) && !defined(AO_HAVE_int_store)
1234 #  define AO_int_store(addr, val) AO_int_store_release(addr,val)
1235 #  define AO_HAVE_int_store
1236 #endif
1237
1238 #if defined(AO_HAVE_int_store_full) && !defined(AO_HAVE_int_store_release)
1239 #  define AO_int_store_release(addr,val) AO_int_store_full(addr,val)
1240 #  define AO_HAVE_int_store_release
1241 #endif
1242
1243 #if defined(AO_HAVE_int_store_full) && !defined(AO_HAVE_int_store_write)
1244 #  define AO_int_store_write(addr,val) AO_int_store_full(addr,val)
1245 #  define AO_HAVE_int_store_write
1246 #endif
1247
1248 #if defined(AO_HAVE_int_store_release) && \
1249         !defined(AO_HAVE_int_store_release_write)
1250 #  define AO_int_store_release_write(addr, val) \
1251         AO_int_store_release(addr,val)
1252 #  define AO_HAVE_int_store_release_write
1253 #endif
1254
1255 #if defined(AO_HAVE_int_store_write) && !defined(AO_HAVE_int_store)
1256 #  define AO_int_store(addr, val) AO_int_store_write(addr,val)
1257 #  define AO_HAVE_int_store
1258 #endif
1259
1260 #if defined(AO_HAVE_int_store) && defined(AO_HAVE_nop_full) && \
1261     !defined(AO_HAVE_int_store_release)
1262 #  define AO_int_store_release(addr,val) \
1263         (AO_nop_full(), AO_int_store(addr,val))
1264 #  define AO_HAVE_int_store_release
1265 #endif
1266
1267 #if defined(AO_HAVE_nop_write) && defined(AO_HAVE_int_store) && \
1268      !defined(AO_HAVE_int_store_write)
1269 #  define AO_int_store_write(addr, val) \
1270         (AO_nop_write(), AO_int_store(addr,val))
1271 #  define AO_HAVE_int_store_write
1272 #endif
1273
1274 #if defined(AO_HAVE_int_store_write) && \
1275      !defined(AO_HAVE_int_store_release_write)
1276 #  define AO_int_store_release_write(addr, val) AO_int_store_write(addr,val)
1277 #  define AO_HAVE_int_store_release_write
1278 #endif
1279
1280 #if defined(AO_HAVE_int_store_release) && defined(AO_HAVE_nop_full) && \
1281     !defined(AO_HAVE_int_store_full)
1282 #  define AO_int_store_full(addr, val) \
1283         (AO_int_store_release(addr, val), AO_nop_full())
1284 #  define AO_HAVE_int_store_full
1285 #endif
1286
1287
1288 /* int_fetch_and_add */
1289 #if defined(AO_HAVE_int_compare_and_swap_full) && \
1290     !defined(AO_HAVE_int_fetch_and_add_full)
1291    AO_INLINE AO_t
1292    AO_int_fetch_and_add_full(volatile unsigned int *addr,
1293                                unsigned int incr)
1294    {
1295      unsigned int old;
1296      do
1297        {
1298          old = *addr;
1299        }
1300      while (!AO_int_compare_and_swap_full(addr, old, old+incr));
1301      return old;
1302    }
1303 #  define AO_HAVE_int_fetch_and_add_full
1304 #endif
1305
1306 #if defined(AO_HAVE_int_compare_and_swap_acquire) && \
1307     !defined(AO_HAVE_int_fetch_and_add_acquire)
1308    AO_INLINE AO_t
1309    AO_int_fetch_and_add_acquire(volatile unsigned int *addr,
1310                                   unsigned int incr)
1311    {
1312      unsigned int old;
1313      do
1314        {
1315          old = *addr;
1316        }
1317      while (!AO_int_compare_and_swap_acquire(addr, old, old+incr));
1318      return old;
1319    }
1320 #  define AO_HAVE_int_fetch_and_add_acquire
1321 #endif
1322
1323 #if defined(AO_HAVE_int_compare_and_swap_release) && \
1324     !defined(AO_HAVE_int_fetch_and_add_release)
1325    AO_INLINE AO_t
1326    AO_int_fetch_and_add_release(volatile unsigned int *addr,
1327                                   unsigned int incr)
1328    {
1329      unsigned int old;
1330      do
1331        {
1332          old = *addr;
1333        }
1334      while (!AO_int_compare_and_swap_release(addr, old, old+incr));
1335      return old;
1336    }
1337 #  define AO_HAVE_int_fetch_and_add_release
1338 #endif
1339
1340 #if defined(AO_HAVE_int_fetch_and_add_full)
1341 #  if !defined(AO_HAVE_int_fetch_and_add_release)
1342 #    define AO_int_fetch_and_add_release(addr, val) \
1343          AO_int_fetch_and_add_full(addr, val)
1344 #    define AO_HAVE_int_fetch_and_add_release
1345 #  endif
1346 #  if !defined(AO_HAVE_int_fetch_and_add_acquire)
1347 #    define AO_int_fetch_and_add_acquire(addr, val) \
1348          AO_int_fetch_and_add_full(addr, val)
1349 #    define AO_HAVE_int_fetch_and_add_acquire
1350 #  endif
1351 #  if !defined(AO_HAVE_int_fetch_and_add_write)
1352 #    define AO_int_fetch_and_add_write(addr, val) \
1353          AO_int_fetch_and_add_full(addr, val)
1354 #    define AO_HAVE_int_fetch_and_add_write
1355 #  endif
1356 #  if !defined(AO_HAVE_int_fetch_and_add_read)
1357 #    define AO_int_fetch_and_add_read(addr, val) \
1358          AO_int_fetch_and_add_full(addr, val)
1359 #    define AO_HAVE_int_fetch_and_add_read
1360 #  endif
1361 #endif /* AO_HAVE_int_fetch_and_add_full */
1362
1363 #if !defined(AO_HAVE_int_fetch_and_add) && \
1364     defined(AO_HAVE_int_fetch_and_add_release)
1365 #  define AO_int_fetch_and_add(addr, val) \
1366         AO_int_fetch_and_add_release(addr, val)
1367 #  define AO_HAVE_int_fetch_and_add
1368 #endif
1369 #if !defined(AO_HAVE_int_fetch_and_add) && \
1370     defined(AO_HAVE_int_fetch_and_add_acquire)
1371 #  define AO_int_fetch_and_add(addr, val) \
1372         AO_int_fetch_and_add_acquire(addr, val)
1373 #  define AO_HAVE_int_fetch_and_add
1374 #endif
1375 #if !defined(AO_HAVE_int_fetch_and_add) && \
1376     defined(AO_HAVE_int_fetch_and_add_write)
1377 #  define AO_int_fetch_and_add(addr, val) \
1378         AO_int_fetch_and_add_write(addr, val)
1379 #  define AO_HAVE_int_fetch_and_add
1380 #endif
1381 #if !defined(AO_HAVE_int_fetch_and_add) && \
1382     defined(AO_HAVE_int_fetch_and_add_read)
1383 #  define AO_int_fetch_and_add(addr, val) \
1384         AO_int_fetch_and_add_read(addr, val)
1385 #  define AO_HAVE_int_fetch_and_add
1386 #endif
1387
1388 #if defined(AO_HAVE_int_fetch_and_add_acquire) &&\
1389     defined(AO_HAVE_nop_full) && \
1390     !defined(AO_HAVE_int_fetch_and_add_full)
1391 #  define AO_int_fetch_and_add_full(addr, val) \
1392         (AO_nop_full(), AO_int_fetch_and_add_acquire(addr, val))
1393 #endif
1394
1395 #if !defined(AO_HAVE_int_fetch_and_add_release_write) && \
1396     defined(AO_HAVE_int_fetch_and_add_write)
1397 #  define AO_int_fetch_and_add_release_write(addr, val) \
1398         AO_int_fetch_and_add_write(addr, val)
1399 #  define AO_HAVE_int_fetch_and_add_release_write
1400 #endif
1401 #if !defined(AO_HAVE_int_fetch_and_add_release_write) && \
1402     defined(AO_HAVE_int_fetch_and_add_release)
1403 #  define AO_int_fetch_and_add_release_write(addr, val) \
1404         AO_int_fetch_and_add_release(addr, val)
1405 #  define AO_HAVE_int_fetch_and_add_release_write
1406 #endif
1407 #if !defined(AO_HAVE_int_fetch_and_add_acquire_read) && \
1408     defined(AO_HAVE_int_fetch_and_add_read)
1409 #  define AO_int_fetch_and_add_acquire_read(addr, val) \
1410         AO_int_fetch_and_add_read(addr, val)
1411 #  define AO_HAVE_int_fetch_and_add_acquire_read
1412 #endif
1413 #if !defined(AO_HAVE_int_fetch_and_add_acquire_read) && \
1414     defined(AO_HAVE_int_fetch_and_add_acquire)
1415 #  define AO_int_fetch_and_add_acquire_read(addr, val) \
1416         AO_int_fetch_and_add_acquire(addr, val)
1417 #  define AO_HAVE_int_fetch_and_add_acquire_read
1418 #endif
1419
1420 #ifdef AO_NO_DD_ORDERING
1421 #  if defined(AO_HAVE_int_fetch_and_add_acquire_read)
1422 #    define AO_int_fetch_and_add_dd_acquire_read(addr, val) \
1423         AO_int_fetch_and_add_acquire_read(addr, val)
1424 #    define AO_HAVE_int_fetch_and_add_dd_acquire_read
1425 #  endif
1426 #else
1427 #  if defined(AO_HAVE_int_fetch_and_add)
1428 #    define AO_int_fetch_and_add_dd_acquire_read(addr, val) \
1429         AO_int_fetch_and_add(addr, val)
1430 #    define AO_HAVE_int_fetch_and_add_dd_acquire_read
1431 #  endif
1432 #endif
1433
1434 /* int_fetch_and_add1 */
1435
1436 #if defined(AO_HAVE_int_fetch_and_add_full) &&\
1437     !defined(AO_HAVE_int_fetch_and_add1_full)
1438 #  define AO_int_fetch_and_add1_full(addr) \
1439         AO_int_fetch_and_add_full(addr,1)
1440 #  define AO_HAVE_int_fetch_and_add1_full
1441 #endif
1442 #if defined(AO_HAVE_int_fetch_and_add_release) &&\
1443     !defined(AO_HAVE_int_fetch_and_add1_release)
1444 #  define AO_int_fetch_and_add1_release(addr) \
1445         AO_int_fetch_and_add_release(addr,1)
1446 #  define AO_HAVE_int_fetch_and_add1_release
1447 #endif
1448 #if defined(AO_HAVE_int_fetch_and_add_acquire) &&\
1449     !defined(AO_HAVE_int_fetch_and_add1_acquire)
1450 #  define AO_int_fetch_and_add1_acquire(addr) \
1451         AO_int_fetch_and_add_acquire(addr,1)
1452 #  define AO_HAVE_int_fetch_and_add1_acquire
1453 #endif
1454 #if defined(AO_HAVE_int_fetch_and_add_write) &&\
1455     !defined(AO_HAVE_int_fetch_and_add1_write)
1456 #  define AO_int_fetch_and_add1_write(addr) \
1457         AO_int_fetch_and_add_write(addr,1)
1458 #  define AO_HAVE_int_fetch_and_add1_write
1459 #endif
1460 #if defined(AO_HAVE_int_fetch_and_add_read) &&\
1461     !defined(AO_HAVE_int_fetch_and_add1_read)
1462 #  define AO_int_fetch_and_add1_read(addr) \
1463         AO_int_fetch_and_add_read(addr,1)
1464 #  define AO_HAVE_int_fetch_and_add1_read
1465 #endif
1466 #if defined(AO_HAVE_int_fetch_and_add_release_write) &&\
1467     !defined(AO_HAVE_int_fetch_and_add1_release_write)
1468 #  define AO_int_fetch_and_add1_release_write(addr) \
1469         AO_int_fetch_and_add_release_write(addr,1)
1470 #  define AO_HAVE_int_fetch_and_add1_release_write
1471 #endif
1472 #if defined(AO_HAVE_int_fetch_and_add_acquire_read) &&\
1473     !defined(AO_HAVE_int_fetch_and_add1_acquire_read)
1474 #  define AO_int_fetch_and_add1_acquire_read(addr) \
1475         AO_int_fetch_and_add_acquire_read(addr,1)
1476 #  define AO_HAVE_int_fetch_and_add1_acquire_read
1477 #endif
1478 #if defined(AO_HAVE_int_fetch_and_add) &&\
1479     !defined(AO_HAVE_int_fetch_and_add1)
1480 #  define AO_int_fetch_and_add1(addr) \
1481         AO_int_fetch_and_add(addr,1)
1482 #  define AO_HAVE_int_fetch_and_add1
1483 #endif
1484
1485 #if defined(AO_HAVE_int_fetch_and_add1_full)
1486 #  if !defined(AO_HAVE_int_fetch_and_add1_release)
1487 #    define AO_int_fetch_and_add1_release(addr) \
1488          AO_int_fetch_and_add1_full(addr)
1489 #    define AO_HAVE_int_fetch_and_add1_release
1490 #  endif
1491 #  if !defined(AO_HAVE_int_fetch_and_add1_acquire)
1492 #    define AO_int_fetch_and_add1_acquire(addr) \
1493          AO_int_fetch_and_add1_full(addr)
1494 #    define AO_HAVE_int_fetch_and_add1_acquire
1495 #  endif
1496 #  if !defined(AO_HAVE_int_fetch_and_add1_write)
1497 #    define AO_int_fetch_and_add1_write(addr) \
1498          AO_int_fetch_and_add1_full(addr)
1499 #    define AO_HAVE_int_fetch_and_add1_write
1500 #  endif
1501 #  if !defined(AO_HAVE_int_fetch_and_add1_read)
1502 #    define AO_int_fetch_and_add1_read(addr) \
1503          AO_int_fetch_and_add1_full(addr)
1504 #    define AO_HAVE_int_fetch_and_add1_read
1505 #  endif
1506 #endif /* AO_HAVE_int_fetch_and_add1_full */
1507
1508 #if !defined(AO_HAVE_int_fetch_and_add1) && \
1509     defined(AO_HAVE_int_fetch_and_add1_release)
1510 #  define AO_int_fetch_and_add1(addr) \
1511         AO_int_fetch_and_add1_release(addr)
1512 #  define AO_HAVE_int_fetch_and_add1
1513 #endif
1514 #if !defined(AO_HAVE_int_fetch_and_add1) && \
1515     defined(AO_HAVE_int_fetch_and_add1_acquire)
1516 #  define AO_int_fetch_and_add1(addr) \
1517         AO_int_fetch_and_add1_acquire(addr)
1518 #  define AO_HAVE_int_fetch_and_add1
1519 #endif
1520 #if !defined(AO_HAVE_int_fetch_and_add1) && \
1521     defined(AO_HAVE_int_fetch_and_add1_write)
1522 #  define AO_int_fetch_and_add1(addr) \
1523         AO_int_fetch_and_add1_write(addr)
1524 #  define AO_HAVE_int_fetch_and_add1
1525 #endif
1526 #if !defined(AO_HAVE_int_fetch_and_add1) && \
1527     defined(AO_HAVE_int_fetch_and_add1_read)
1528 #  define AO_int_fetch_and_add1(addr) \
1529         AO_int_fetch_and_add1_read(addr)
1530 #  define AO_HAVE_int_fetch_and_add1
1531 #endif
1532
1533 #if defined(AO_HAVE_int_fetch_and_add1_acquire) &&\
1534     defined(AO_HAVE_nop_full) && \
1535     !defined(AO_HAVE_int_fetch_and_add1_full)
1536 #  define AO_int_fetch_and_add1_full(addr) \
1537         (AO_nop_full(), AO_int_fetch_and_add1_acquire(addr))
1538 #  define AO_HAVE_int_fetch_and_add1_full
1539 #endif
1540
1541 #if !defined(AO_HAVE_int_fetch_and_add1_release_write) && \
1542     defined(AO_HAVE_int_fetch_and_add1_write)
1543 #  define AO_int_fetch_and_add1_release_write(addr) \
1544         AO_int_fetch_and_add1_write(addr)
1545 #  define AO_HAVE_int_fetch_and_add1_release_write
1546 #endif
1547 #if !defined(AO_HAVE_int_fetch_and_add1_release_write) && \
1548     defined(AO_HAVE_int_fetch_and_add1_release)
1549 #  define AO_int_fetch_and_add1_release_write(addr) \
1550         AO_int_fetch_and_add1_release(addr)
1551 #  define AO_HAVE_int_fetch_and_add1_release_write
1552 #endif
1553 #if !defined(AO_HAVE_int_fetch_and_add1_acquire_read) && \
1554     defined(AO_HAVE_int_fetch_and_add1_read)
1555 #  define AO_int_fetch_and_add1_acquire_read(addr) \
1556         AO_int_fetch_and_add1_read(addr)
1557 #  define AO_HAVE_int_fetch_and_add1_acquire_read
1558 #endif
1559 #if !defined(AO_HAVE_int_fetch_and_add1_acquire_read) && \
1560     defined(AO_HAVE_int_fetch_and_add1_acquire)
1561 #  define AO_int_fetch_and_add1_acquire_read(addr) \
1562         AO_int_fetch_and_add1_acquire(addr)
1563 #  define AO_HAVE_int_fetch_and_add1_acquire_read
1564 #endif
1565
1566 #ifdef AO_NO_DD_ORDERING
1567 #  if defined(AO_HAVE_int_fetch_and_add1_acquire_read)
1568 #    define AO_int_fetch_and_add1_dd_acquire_read(addr) \
1569         AO_int_fetch_and_add1_acquire_read(addr)
1570 #    define AO_HAVE_int_fetch_and_add1_dd_acquire_read
1571 #  endif
1572 #else
1573 #  if defined(AO_HAVE_int_fetch_and_add1)
1574 #    define AO_int_fetch_and_add1_dd_acquire_read(addr) \
1575         AO_int_fetch_and_add1(addr)
1576 #    define AO_HAVE_int_fetch_and_add1_dd_acquire_read
1577 #  endif
1578 #endif
1579
1580 /* int_fetch_and_sub1 */
1581
1582 #if defined(AO_HAVE_int_fetch_and_add_full) &&\
1583     !defined(AO_HAVE_int_fetch_and_sub1_full)
1584 #  define AO_int_fetch_and_sub1_full(addr) \
1585         AO_int_fetch_and_add_full(addr,(unsigned int)(-1))
1586 #  define AO_HAVE_int_fetch_and_sub1_full
1587 #endif
1588 #if defined(AO_HAVE_int_fetch_and_add_release) &&\
1589     !defined(AO_HAVE_int_fetch_and_sub1_release)
1590 #  define AO_int_fetch_and_sub1_release(addr) \
1591         AO_int_fetch_and_add_release(addr,(unsigned int)(-1))
1592 #  define AO_HAVE_int_fetch_and_sub1_release
1593 #endif
1594 #if defined(AO_HAVE_int_fetch_and_add_acquire) &&\
1595     !defined(AO_HAVE_int_fetch_and_sub1_acquire)
1596 #  define AO_int_fetch_and_sub1_acquire(addr) \
1597         AO_int_fetch_and_add_acquire(addr,(unsigned int)(-1))
1598 #  define AO_HAVE_int_fetch_and_sub1_acquire
1599 #endif
1600 #if defined(AO_HAVE_int_fetch_and_add_write) &&\
1601     !defined(AO_HAVE_int_fetch_and_sub1_write)
1602 #  define AO_int_fetch_and_sub1_write(addr) \
1603         AO_int_fetch_and_add_write(addr,(unsigned int)(-1))
1604 #  define AO_HAVE_int_fetch_and_sub1_write
1605 #endif
1606 #if defined(AO_HAVE_int_fetch_and_add_read) &&\
1607     !defined(AO_HAVE_int_fetch_and_sub1_read)
1608 #  define AO_int_fetch_and_sub1_read(addr) \
1609         AO_int_fetch_and_add_read(addr,(unsigned int)(-1))
1610 #  define AO_HAVE_int_fetch_and_sub1_read
1611 #endif
1612 #if defined(AO_HAVE_int_fetch_and_add_release_write) &&\
1613     !defined(AO_HAVE_int_fetch_and_sub1_release_write)
1614 #  define AO_int_fetch_and_sub1_release_write(addr) \
1615         AO_int_fetch_and_add_release_write(addr,(unsigned int)(-1))
1616 #  define AO_HAVE_int_fetch_and_sub1_release_write
1617 #endif
1618 #if defined(AO_HAVE_int_fetch_and_add_acquire_read) &&\
1619     !defined(AO_HAVE_int_fetch_and_sub1_acquire_read)
1620 #  define AO_int_fetch_and_sub1_acquire_read(addr) \
1621         AO_int_fetch_and_add_acquire_read(addr,(unsigned int)(-1))
1622 #  define AO_HAVE_int_fetch_and_sub1_acquire_read
1623 #endif
1624 #if defined(AO_HAVE_int_fetch_and_add) &&\
1625     !defined(AO_HAVE_int_fetch_and_sub1)
1626 #  define AO_int_fetch_and_sub1(addr) \
1627         AO_int_fetch_and_add(addr,(unsigned int)(-1))
1628 #  define AO_HAVE_int_fetch_and_sub1
1629 #endif
1630
1631 #if defined(AO_HAVE_int_fetch_and_sub1_full)
1632 #  if !defined(AO_HAVE_int_fetch_and_sub1_release)
1633 #    define AO_int_fetch_and_sub1_release(addr) \
1634          AO_int_fetch_and_sub1_full(addr)
1635 #    define AO_HAVE_int_fetch_and_sub1_release
1636 #  endif
1637 #  if !defined(AO_HAVE_int_fetch_and_sub1_acquire)
1638 #    define AO_int_fetch_and_sub1_acquire(addr) \
1639          AO_int_fetch_and_sub1_full(addr)
1640 #    define AO_HAVE_int_fetch_and_sub1_acquire
1641 #  endif
1642 #  if !defined(AO_HAVE_int_fetch_and_sub1_write)
1643 #    define AO_int_fetch_and_sub1_write(addr) \
1644          AO_int_fetch_and_sub1_full(addr)
1645 #    define AO_HAVE_int_fetch_and_sub1_write
1646 #  endif
1647 #  if !defined(AO_HAVE_int_fetch_and_sub1_read)
1648 #    define AO_int_fetch_and_sub1_read(addr) \
1649          AO_int_fetch_and_sub1_full(addr)
1650 #    define AO_HAVE_int_fetch_and_sub1_read
1651 #  endif
1652 #endif /* AO_HAVE_int_fetch_and_sub1_full */
1653
1654 #if !defined(AO_HAVE_int_fetch_and_sub1) && \
1655     defined(AO_HAVE_int_fetch_and_sub1_release)
1656 #  define AO_int_fetch_and_sub1(addr) \
1657         AO_int_fetch_and_sub1_release(addr)
1658 #  define AO_HAVE_int_fetch_and_sub1
1659 #endif
1660 #if !defined(AO_HAVE_int_fetch_and_sub1) && \
1661     defined(AO_HAVE_int_fetch_and_sub1_acquire)
1662 #  define AO_int_fetch_and_sub1(addr) \
1663         AO_int_fetch_and_sub1_acquire(addr)
1664 #  define AO_HAVE_int_fetch_and_sub1
1665 #endif
1666 #if !defined(AO_HAVE_int_fetch_and_sub1) && \
1667     defined(AO_HAVE_int_fetch_and_sub1_write)
1668 #  define AO_int_fetch_and_sub1(addr) \
1669         AO_int_fetch_and_sub1_write(addr)
1670 #  define AO_HAVE_int_fetch_and_sub1
1671 #endif
1672 #if !defined(AO_HAVE_int_fetch_and_sub1) && \
1673     defined(AO_HAVE_int_fetch_and_sub1_read)
1674 #  define AO_int_fetch_and_sub1(addr) \
1675         AO_int_fetch_and_sub1_read(addr)
1676 #  define AO_HAVE_int_fetch_and_sub1
1677 #endif
1678
1679 #if defined(AO_HAVE_int_fetch_and_sub1_acquire) &&\
1680     defined(AO_HAVE_nop_full) && \
1681     !defined(AO_HAVE_int_fetch_and_sub1_full)
1682 #  define AO_int_fetch_and_sub1_full(addr) \
1683         (AO_nop_full(), AO_int_fetch_and_sub1_acquire(addr))
1684 #  define AO_HAVE_int_fetch_and_sub1_full
1685 #endif
1686
1687 #if !defined(AO_HAVE_int_fetch_and_sub1_release_write) && \
1688     defined(AO_HAVE_int_fetch_and_sub1_write)
1689 #  define AO_int_fetch_and_sub1_release_write(addr) \
1690         AO_int_fetch_and_sub1_write(addr)
1691 #  define AO_HAVE_int_fetch_and_sub1_release_write
1692 #endif
1693 #if !defined(AO_HAVE_int_fetch_and_sub1_release_write) && \
1694     defined(AO_HAVE_int_fetch_and_sub1_release)
1695 #  define AO_int_fetch_and_sub1_release_write(addr) \
1696         AO_int_fetch_and_sub1_release(addr)
1697 #  define AO_HAVE_int_fetch_and_sub1_release_write
1698 #endif
1699 #if !defined(AO_HAVE_int_fetch_and_sub1_acquire_read) && \
1700     defined(AO_HAVE_int_fetch_and_sub1_read)
1701 #  define AO_int_fetch_and_sub1_acquire_read(addr) \
1702         AO_int_fetch_and_sub1_read(addr)
1703 #  define AO_HAVE_int_fetch_and_sub1_acquire_read
1704 #endif
1705 #if !defined(AO_HAVE_int_fetch_and_sub1_acquire_read) && \
1706     defined(AO_HAVE_int_fetch_and_sub1_acquire)
1707 #  define AO_int_fetch_and_sub1_acquire_read(addr) \
1708         AO_int_fetch_and_sub1_acquire(addr)
1709 #  define AO_HAVE_int_fetch_and_sub1_acquire_read
1710 #endif
1711
1712 #ifdef AO_NO_DD_ORDERING
1713 #  if defined(AO_HAVE_int_fetch_and_sub1_acquire_read)
1714 #    define AO_int_fetch_and_sub1_dd_acquire_read(addr) \
1715         AO_int_fetch_and_sub1_acquire_read(addr)
1716 #    define AO_HAVE_int_fetch_and_sub1_dd_acquire_read
1717 #  endif
1718 #else
1719 #  if defined(AO_HAVE_int_fetch_and_sub1)
1720 #    define AO_int_fetch_and_sub1_dd_acquire_read(addr) \
1721         AO_int_fetch_and_sub1(addr)
1722 #    define AO_HAVE_int_fetch_and_sub1_dd_acquire_read
1723 #  endif
1724 #endif
1725