src/mm/boehm-gc/libatomic_ops-1.2/tests/test_atomic_include.h

   1 /*
   2  * Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
   3  *
   4  * This file is covered by the GNU general public license, version 2.
   5  * see doc/COPYING for details.
   6  */
   7
   8 /* Some basic sanity tests.  These do not test the barrier semantics. */
   9
  10 #undef TA_assert
  11 #define TA_assert(e) \
  12   if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: )\n", \
  13                     __FILE__, __LINE__), exit(1); }
  14
  15 #undef MISSING
  16 #define MISSING(name) \
  17   fprintf(stderr, "Missing: %s\n", #name "")
  18
  19 void test_atomic(void)
  20 {
  21   AO_t x;
  22   unsigned char b;
  23   unsigned short s;
  24   unsigned int zz;
  25 # if defined(AO_HAVE_test_and_set)
  26     AO_TS_t z = AO_TS_INITIALIZER;
  27 # endif
  28 # if defined(AO_HAVE_double_t)
  29     AO_double_t w;
  30     w.AO_val1 = 0;
  31     w.AO_val2 = 0;
  32 # endif
  33
  34 # if defined(AO_HAVE_nop)
  35     AO_nop();
  36 # else
  37     MISSING(AO_nop);
  38 # endif
  39 # if defined(AO_HAVE_store)
  40     AO_store(&x, 13);
  41     TA_assert (x == 13);
  42 # else
  43     MISSING(AO_store);
  44     x = 13;
  45 # endif
  46 # if defined(AO_HAVE_load)
  47     TA_assert(AO_load(&x) == 13);
  48 # else
  49     MISSING(AO_load);
  50 # endif
  51 # if defined(AO_HAVE_test_and_set)
  52     assert(AO_test_and_set(&z) == AO_TS_CLEAR);
  53     assert(AO_test_and_set(&z) == AO_TS_SET);
  54     assert(AO_test_and_set(&z) == AO_TS_SET);
  55     AO_CLEAR(&z);
  56 # else
  57     MISSING(AO_test_and_set);
  58 # endif
  59 # if defined(AO_HAVE_fetch_and_add)
  60     TA_assert(AO_fetch_and_add(&x, 42) == 13);
  61     TA_assert(AO_fetch_and_add(&x, -42) == 55);
  62 # else
  63     MISSING(AO_fetch_and_add);
  64 # endif
  65 # if defined(AO_HAVE_fetch_and_add1)
  66     TA_assert(AO_fetch_and_add1(&x) == 13);
  67 # else
  68     MISSING(AO_fetch_and_add1);
  69     ++x;
  70 # endif
  71 # if defined(AO_HAVE_fetch_and_sub1)
  72     TA_assert(AO_fetch_and_sub1(&x) == 14);
  73 # else
  74     MISSING(AO_fetch_and_sub1);
  75     --x;
  76 # endif
  77 # if defined(AO_HAVE_short_store)
  78     AO_short_store(&s, 13);
  79 # else
  80     MISSING(AO_short_store);
  81     s = 13;
  82 # endif
  83 # if defined(AO_HAVE_short_load)
  84     TA_assert(AO_short_load(&s) == 13);
  85 # else
  86     MISSING(AO_short_load);
  87 # endif
  88 # if defined(AO_HAVE_short_fetch_and_add)
  89     TA_assert(AO_short_fetch_and_add(&s, 42) == 13);
  90     TA_assert(AO_short_fetch_and_add(&s, -42) == 55);
  91 # else
  92     MISSING(AO_short_fetch_and_add);
  93 # endif
  94 # if defined(AO_HAVE_short_fetch_and_add1)
  95     TA_assert(AO_short_fetch_and_add1(&s) == 13);
  96 # else
  97     MISSING(AO_short_fetch_and_add1);
  98     ++s;
  99 # endif
 100 # if defined(AO_HAVE_short_fetch_and_sub1)
 101     TA_assert(AO_short_fetch_and_sub1(&s) == 14);
 102 # else
 103     MISSING(AO_short_fetch_and_sub1);
 104     --s;
 105 # endif
 106 # if defined(AO_HAVE_char_store)
 107     AO_char_store(&b, 13);
 108 # else
 109     MISSING(AO_char_store);
 110     b = 13;
 111 # endif
 112 # if defined(AO_HAVE_char_load)
 113     TA_assert(AO_char_load(&b) == 13);
 114 # else
 115     MISSING(AO_char_load);
 116 # endif
 117 # if defined(AO_HAVE_char_fetch_and_add)
 118     TA_assert(AO_char_fetch_and_add(&b, 42) == 13);
 119     TA_assert(AO_char_fetch_and_add(&b, -42) == 55);
 120 # else
 121     MISSING(AO_char_fetch_and_add);
 122 # endif
 123 # if defined(AO_HAVE_char_fetch_and_add1)
 124     TA_assert(AO_char_fetch_and_add1(&b) == 13);
 125 # else
 126     MISSING(AO_char_fetch_and_add1);
 127     ++b;
 128 # endif
 129 # if defined(AO_HAVE_char_fetch_and_sub1)
 130     TA_assert(AO_char_fetch_and_sub1(&b) == 14);
 131 # else
 132     MISSING(AO_char_fetch_and_sub1);
 133     --b;
 134 # endif
 135 # if defined(AO_HAVE_int_store)
 136     AO_int_store(&zz, 13);
 137 # else
 138     MISSING(AO_int_store);
 139     zz = 13;
 140 # endif
 141 # if defined(AO_HAVE_int_load)
 142     TA_assert(AO_int_load(&zz) == 13);
 143 # else
 144     MISSING(AO_int_load);
 145 # endif
 146 # if defined(AO_HAVE_int_fetch_and_add)
 147     TA_assert(AO_int_fetch_and_add(&zz, 42) == 13);
 148     TA_assert(AO_int_fetch_and_add(&zz, -42) == 55);
 149 # else
 150     MISSING(AO_int_fetch_and_add);
 151 # endif
 152 # if defined(AO_HAVE_int_fetch_and_add1)
 153     TA_assert(AO_int_fetch_and_add1(&zz) == 13);
 154 # else
 155     MISSING(AO_int_fetch_and_add1);
 156     ++zz;
 157 # endif
 158 # if defined(AO_HAVE_int_fetch_and_sub1)
 159     TA_assert(AO_int_fetch_and_sub1(&zz) == 14);
 160 # else
 161     MISSING(AO_int_fetch_and_sub1);
 162     --zz;
 163 # endif
 164 # if defined(AO_HAVE_compare_and_swap)
 165     TA_assert(!AO_compare_and_swap(&x, 14, 42));
 166     TA_assert(x == 13);
 167     TA_assert(AO_compare_and_swap(&x, 13, 42));
 168     TA_assert(x == 42);
 169 # else
 170     MISSING(AO_compare_and_swap);
 171 # endif
 172 # if defined(AO_HAVE_or)
 173     AO_or(&x, 66);
 174     TA_assert(x == 106);
 175 # else
 176     MISSING(AO_or);
 177     x |= 34;
 178 # endif
 179 # if defined(AO_HAVE_compare_double_and_swap_double)
 180     TA_assert(!AO_compare_double_and_swap_double(&w, 17, 42, 12, 13));
 181     TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 182     TA_assert(AO_compare_double_and_swap_double(&w, 0, 0, 12, 13));
 183     TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 184     TA_assert(AO_compare_double_and_swap_double(&w, 12, 13, 17, 42));
 185     TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 186     w.AO_val1 = 0; w.AO_val2 = 0;
 187 # else
 188     MISSING(AO_compare_double_and_swap_double);
 189 # endif
 190 # if defined(AO_HAVE_compare_and_swap_double)
 191     TA_assert(!AO_compare_and_swap_double(&w, 17, 12, 13));
 192     TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 193     TA_assert(AO_compare_and_swap_double(&w, 0, 12, 13));
 194     TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 195     TA_assert(AO_compare_and_swap_double(&w, 12, 17, 42));
 196     TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 197 # else
 198     MISSING(AO_compare_and_swap_double);
 199 # endif
 200 }
 201
 202
 203
 204 /*
 205  * Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
 206  *
 207  * This file is covered by the GNU general public license, version 2.
 208  * see doc/COPYING for details.
 209  */
 210
 211 /* Some basic sanity tests.  These do not test the barrier semantics. */
 212
 213 #undef TA_assert
 214 #define TA_assert(e) \
 215   if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: _release)\n", \
 216                     __FILE__, __LINE__), exit(1); }
 217
 218 #undef MISSING
 219 #define MISSING(name) \
 220   fprintf(stderr, "Missing: %s\n", #name "_release")
 221
 222 void test_atomic_release(void)
 223 {
 224   AO_t x;
 225   unsigned char b;
 226   unsigned short s;
 227   unsigned int zz;
 228 # if defined(AO_HAVE_test_and_set_release)
 229     AO_TS_t z = AO_TS_INITIALIZER;
 230 # endif
 231 # if defined(AO_HAVE_double_t)
 232     AO_double_t w;
 233     w.AO_val1 = 0;
 234     w.AO_val2 = 0;
 235 # endif
 236
 237 # if defined(AO_HAVE_nop_release)
 238     AO_nop_release();
 239 # else
 240     MISSING(AO_nop);
 241 # endif
 242 # if defined(AO_HAVE_store_release)
 243     AO_store_release(&x, 13);
 244     TA_assert (x == 13);
 245 # else
 246     MISSING(AO_store);
 247     x = 13;
 248 # endif
 249 # if defined(AO_HAVE_load_release)
 250     TA_assert(AO_load_release(&x) == 13);
 251 # else
 252     MISSING(AO_load);
 253 # endif
 254 # if defined(AO_HAVE_test_and_set_release)
 255     assert(AO_test_and_set_release(&z) == AO_TS_CLEAR);
 256     assert(AO_test_and_set_release(&z) == AO_TS_SET);
 257     assert(AO_test_and_set_release(&z) == AO_TS_SET);
 258     AO_CLEAR(&z);
 259 # else
 260     MISSING(AO_test_and_set);
 261 # endif
 262 # if defined(AO_HAVE_fetch_and_add_release)
 263     TA_assert(AO_fetch_and_add_release(&x, 42) == 13);
 264     TA_assert(AO_fetch_and_add_release(&x, -42) == 55);
 265 # else
 266     MISSING(AO_fetch_and_add);
 267 # endif
 268 # if defined(AO_HAVE_fetch_and_add1_release)
 269     TA_assert(AO_fetch_and_add1_release(&x) == 13);
 270 # else
 271     MISSING(AO_fetch_and_add1);
 272     ++x;
 273 # endif
 274 # if defined(AO_HAVE_fetch_and_sub1_release)
 275     TA_assert(AO_fetch_and_sub1_release(&x) == 14);
 276 # else
 277     MISSING(AO_fetch_and_sub1);
 278     --x;
 279 # endif
 280 # if defined(AO_HAVE_short_store_release)
 281     AO_short_store_release(&s, 13);
 282 # else
 283     MISSING(AO_short_store);
 284     s = 13;
 285 # endif
 286 # if defined(AO_HAVE_short_load_release)
 287     TA_assert(AO_short_load(&s) == 13);
 288 # else
 289     MISSING(AO_short_load);
 290 # endif
 291 # if defined(AO_HAVE_short_fetch_and_add_release)
 292     TA_assert(AO_short_fetch_and_add_release(&s, 42) == 13);
 293     TA_assert(AO_short_fetch_and_add_release(&s, -42) == 55);
 294 # else
 295     MISSING(AO_short_fetch_and_add);
 296 # endif
 297 # if defined(AO_HAVE_short_fetch_and_add1_release)
 298     TA_assert(AO_short_fetch_and_add1_release(&s) == 13);
 299 # else
 300     MISSING(AO_short_fetch_and_add1);
 301     ++s;
 302 # endif
 303 # if defined(AO_HAVE_short_fetch_and_sub1_release)
 304     TA_assert(AO_short_fetch_and_sub1_release(&s) == 14);
 305 # else
 306     MISSING(AO_short_fetch_and_sub1);
 307     --s;
 308 # endif
 309 # if defined(AO_HAVE_char_store_release)
 310     AO_char_store_release(&b, 13);
 311 # else
 312     MISSING(AO_char_store);
 313     b = 13;
 314 # endif
 315 # if defined(AO_HAVE_char_load_release)
 316     TA_assert(AO_char_load(&b) == 13);
 317 # else
 318     MISSING(AO_char_load);
 319 # endif
 320 # if defined(AO_HAVE_char_fetch_and_add_release)
 321     TA_assert(AO_char_fetch_and_add_release(&b, 42) == 13);
 322     TA_assert(AO_char_fetch_and_add_release(&b, -42) == 55);
 323 # else
 324     MISSING(AO_char_fetch_and_add);
 325 # endif
 326 # if defined(AO_HAVE_char_fetch_and_add1_release)
 327     TA_assert(AO_char_fetch_and_add1_release(&b) == 13);
 328 # else
 329     MISSING(AO_char_fetch_and_add1);
 330     ++b;
 331 # endif
 332 # if defined(AO_HAVE_char_fetch_and_sub1_release)
 333     TA_assert(AO_char_fetch_and_sub1_release(&b) == 14);
 334 # else
 335     MISSING(AO_char_fetch_and_sub1);
 336     --b;
 337 # endif
 338 # if defined(AO_HAVE_int_store_release)
 339     AO_int_store_release(&zz, 13);
 340 # else
 341     MISSING(AO_int_store);
 342     zz = 13;
 343 # endif
 344 # if defined(AO_HAVE_int_load_release)
 345     TA_assert(AO_int_load(&zz) == 13);
 346 # else
 347     MISSING(AO_int_load);
 348 # endif
 349 # if defined(AO_HAVE_int_fetch_and_add_release)
 350     TA_assert(AO_int_fetch_and_add_release(&zz, 42) == 13);
 351     TA_assert(AO_int_fetch_and_add_release(&zz, -42) == 55);
 352 # else
 353     MISSING(AO_int_fetch_and_add);
 354 # endif
 355 # if defined(AO_HAVE_int_fetch_and_add1_release)
 356     TA_assert(AO_int_fetch_and_add1_release(&zz) == 13);
 357 # else
 358     MISSING(AO_int_fetch_and_add1);
 359     ++zz;
 360 # endif
 361 # if defined(AO_HAVE_int_fetch_and_sub1_release)
 362     TA_assert(AO_int_fetch_and_sub1_release(&zz) == 14);
 363 # else
 364     MISSING(AO_int_fetch_and_sub1);
 365     --zz;
 366 # endif
 367 # if defined(AO_HAVE_compare_and_swap_release)
 368     TA_assert(!AO_compare_and_swap_release(&x, 14, 42));
 369     TA_assert(x == 13);
 370     TA_assert(AO_compare_and_swap_release(&x, 13, 42));
 371     TA_assert(x == 42);
 372 # else
 373     MISSING(AO_compare_and_swap);
 374 # endif
 375 # if defined(AO_HAVE_or_release)
 376     AO_or_release(&x, 66);
 377     TA_assert(x == 106);
 378 # else
 379     MISSING(AO_or);
 380     x |= 34;
 381 # endif
 382 # if defined(AO_HAVE_compare_double_and_swap_double_release)
 383     TA_assert(!AO_compare_double_and_swap_double_release(&w, 17, 42, 12, 13));
 384     TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 385     TA_assert(AO_compare_double_and_swap_double_release(&w, 0, 0, 12, 13));
 386     TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 387     TA_assert(AO_compare_double_and_swap_double_release(&w, 12, 13, 17, 42));
 388     TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 389     w.AO_val1 = 0; w.AO_val2 = 0;
 390 # else
 391     MISSING(AO_compare_double_and_swap_double);
 392 # endif
 393 # if defined(AO_HAVE_compare_and_swap_double_release)
 394     TA_assert(!AO_compare_and_swap_double_release(&w, 17, 12, 13));
 395     TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 396     TA_assert(AO_compare_and_swap_double_release(&w, 0, 12, 13));
 397     TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 398     TA_assert(AO_compare_and_swap_double_release(&w, 12, 17, 42));
 399     TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 400 # else
 401     MISSING(AO_compare_and_swap_double);
 402 # endif
 403 }
 404
 405
 406
 407 /*
 408  * Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
 409  *
 410  * This file is covered by the GNU general public license, version 2.
 411  * see doc/COPYING for details.
 412  */
 413
 414 /* Some basic sanity tests.  These do not test the barrier semantics. */
 415
 416 #undef TA_assert
 417 #define TA_assert(e) \
 418   if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: _acquire)\n", \
 419                     __FILE__, __LINE__), exit(1); }
 420
 421 #undef MISSING
 422 #define MISSING(name) \
 423   fprintf(stderr, "Missing: %s\n", #name "_acquire")
 424
 425 void test_atomic_acquire(void)
 426 {
 427   AO_t x;
 428   unsigned char b;
 429   unsigned short s;
 430   unsigned int zz;
 431 # if defined(AO_HAVE_test_and_set_acquire)
 432     AO_TS_t z = AO_TS_INITIALIZER;
 433 # endif
 434 # if defined(AO_HAVE_double_t)
 435     AO_double_t w;
 436     w.AO_val1 = 0;
 437     w.AO_val2 = 0;
 438 # endif
 439
 440 # if defined(AO_HAVE_nop_acquire)
 441     AO_nop_acquire();
 442 # else
 443     MISSING(AO_nop);
 444 # endif
 445 # if defined(AO_HAVE_store_acquire)
 446     AO_store_acquire(&x, 13);
 447     TA_assert (x == 13);
 448 # else
 449     MISSING(AO_store);
 450     x = 13;
 451 # endif
 452 # if defined(AO_HAVE_load_acquire)
 453     TA_assert(AO_load_acquire(&x) == 13);
 454 # else
 455     MISSING(AO_load);
 456 # endif
 457 # if defined(AO_HAVE_test_and_set_acquire)
 458     assert(AO_test_and_set_acquire(&z) == AO_TS_CLEAR);
 459     assert(AO_test_and_set_acquire(&z) == AO_TS_SET);
 460     assert(AO_test_and_set_acquire(&z) == AO_TS_SET);
 461     AO_CLEAR(&z);
 462 # else
 463     MISSING(AO_test_and_set);
 464 # endif
 465 # if defined(AO_HAVE_fetch_and_add_acquire)
 466     TA_assert(AO_fetch_and_add_acquire(&x, 42) == 13);
 467     TA_assert(AO_fetch_and_add_acquire(&x, -42) == 55);
 468 # else
 469     MISSING(AO_fetch_and_add);
 470 # endif
 471 # if defined(AO_HAVE_fetch_and_add1_acquire)
 472     TA_assert(AO_fetch_and_add1_acquire(&x) == 13);
 473 # else
 474     MISSING(AO_fetch_and_add1);
 475     ++x;
 476 # endif
 477 # if defined(AO_HAVE_fetch_and_sub1_acquire)
 478     TA_assert(AO_fetch_and_sub1_acquire(&x) == 14);
 479 # else
 480     MISSING(AO_fetch_and_sub1);
 481     --x;
 482 # endif
 483 # if defined(AO_HAVE_short_store_acquire)
 484     AO_short_store_acquire(&s, 13);
 485 # else
 486     MISSING(AO_short_store);
 487     s = 13;
 488 # endif
 489 # if defined(AO_HAVE_short_load_acquire)
 490     TA_assert(AO_short_load(&s) == 13);
 491 # else
 492     MISSING(AO_short_load);
 493 # endif
 494 # if defined(AO_HAVE_short_fetch_and_add_acquire)
 495     TA_assert(AO_short_fetch_and_add_acquire(&s, 42) == 13);
 496     TA_assert(AO_short_fetch_and_add_acquire(&s, -42) == 55);
 497 # else
 498     MISSING(AO_short_fetch_and_add);
 499 # endif
 500 # if defined(AO_HAVE_short_fetch_and_add1_acquire)
 501     TA_assert(AO_short_fetch_and_add1_acquire(&s) == 13);
 502 # else
 503     MISSING(AO_short_fetch_and_add1);
 504     ++s;
 505 # endif
 506 # if defined(AO_HAVE_short_fetch_and_sub1_acquire)
 507     TA_assert(AO_short_fetch_and_sub1_acquire(&s) == 14);
 508 # else
 509     MISSING(AO_short_fetch_and_sub1);
 510     --s;
 511 # endif
 512 # if defined(AO_HAVE_char_store_acquire)
 513     AO_char_store_acquire(&b, 13);
 514 # else
 515     MISSING(AO_char_store);
 516     b = 13;
 517 # endif
 518 # if defined(AO_HAVE_char_load_acquire)
 519     TA_assert(AO_char_load(&b) == 13);
 520 # else
 521     MISSING(AO_char_load);
 522 # endif
 523 # if defined(AO_HAVE_char_fetch_and_add_acquire)
 524     TA_assert(AO_char_fetch_and_add_acquire(&b, 42) == 13);
 525     TA_assert(AO_char_fetch_and_add_acquire(&b, -42) == 55);
 526 # else
 527     MISSING(AO_char_fetch_and_add);
 528 # endif
 529 # if defined(AO_HAVE_char_fetch_and_add1_acquire)
 530     TA_assert(AO_char_fetch_and_add1_acquire(&b) == 13);
 531 # else
 532     MISSING(AO_char_fetch_and_add1);
 533     ++b;
 534 # endif
 535 # if defined(AO_HAVE_char_fetch_and_sub1_acquire)
 536     TA_assert(AO_char_fetch_and_sub1_acquire(&b) == 14);
 537 # else
 538     MISSING(AO_char_fetch_and_sub1);
 539     --b;
 540 # endif
 541 # if defined(AO_HAVE_int_store_acquire)
 542     AO_int_store_acquire(&zz, 13);
 543 # else
 544     MISSING(AO_int_store);
 545     zz = 13;
 546 # endif
 547 # if defined(AO_HAVE_int_load_acquire)
 548     TA_assert(AO_int_load(&zz) == 13);
 549 # else
 550     MISSING(AO_int_load);
 551 # endif
 552 # if defined(AO_HAVE_int_fetch_and_add_acquire)
 553     TA_assert(AO_int_fetch_and_add_acquire(&zz, 42) == 13);
 554     TA_assert(AO_int_fetch_and_add_acquire(&zz, -42) == 55);
 555 # else
 556     MISSING(AO_int_fetch_and_add);
 557 # endif
 558 # if defined(AO_HAVE_int_fetch_and_add1_acquire)
 559     TA_assert(AO_int_fetch_and_add1_acquire(&zz) == 13);
 560 # else
 561     MISSING(AO_int_fetch_and_add1);
 562     ++zz;
 563 # endif
 564 # if defined(AO_HAVE_int_fetch_and_sub1_acquire)
 565     TA_assert(AO_int_fetch_and_sub1_acquire(&zz) == 14);
 566 # else
 567     MISSING(AO_int_fetch_and_sub1);
 568     --zz;
 569 # endif
 570 # if defined(AO_HAVE_compare_and_swap_acquire)
 571     TA_assert(!AO_compare_and_swap_acquire(&x, 14, 42));
 572     TA_assert(x == 13);
 573     TA_assert(AO_compare_and_swap_acquire(&x, 13, 42));
 574     TA_assert(x == 42);
 575 # else
 576     MISSING(AO_compare_and_swap);
 577 # endif
 578 # if defined(AO_HAVE_or_acquire)
 579     AO_or_acquire(&x, 66);
 580     TA_assert(x == 106);
 581 # else
 582     MISSING(AO_or);
 583     x |= 34;
 584 # endif
 585 # if defined(AO_HAVE_compare_double_and_swap_double_acquire)
 586     TA_assert(!AO_compare_double_and_swap_double_acquire(&w, 17, 42, 12, 13));
 587     TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 588     TA_assert(AO_compare_double_and_swap_double_acquire(&w, 0, 0, 12, 13));
 589     TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 590     TA_assert(AO_compare_double_and_swap_double_acquire(&w, 12, 13, 17, 42));
 591     TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 592     w.AO_val1 = 0; w.AO_val2 = 0;
 593 # else
 594     MISSING(AO_compare_double_and_swap_double);
 595 # endif
 596 # if defined(AO_HAVE_compare_and_swap_double_acquire)
 597     TA_assert(!AO_compare_and_swap_double_acquire(&w, 17, 12, 13));
 598     TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 599     TA_assert(AO_compare_and_swap_double_acquire(&w, 0, 12, 13));
 600     TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 601     TA_assert(AO_compare_and_swap_double_acquire(&w, 12, 17, 42));
 602     TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 603 # else
 604     MISSING(AO_compare_and_swap_double);
 605 # endif
 606 }
 607
 608
 609
 610 /*
 611  * Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
 612  *
 613  * This file is covered by the GNU general public license, version 2.
 614  * see doc/COPYING for details.
 615  */
 616
 617 /* Some basic sanity tests.  These do not test the barrier semantics. */
 618
 619 #undef TA_assert
 620 #define TA_assert(e) \
 621   if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: _read)\n", \
 622                     __FILE__, __LINE__), exit(1); }
 623
 624 #undef MISSING
 625 #define MISSING(name) \
 626   fprintf(stderr, "Missing: %s\n", #name "_read")
 627
 628 void test_atomic_read(void)
 629 {
 630   AO_t x;
 631   unsigned char b;
 632   unsigned short s;
 633   unsigned int zz;
 634 # if defined(AO_HAVE_test_and_set_read)
 635     AO_TS_t z = AO_TS_INITIALIZER;
 636 # endif
 637 # if defined(AO_HAVE_double_t)
 638     AO_double_t w;
 639     w.AO_val1 = 0;
 640     w.AO_val2 = 0;
 641 # endif
 642
 643 # if defined(AO_HAVE_nop_read)
 644     AO_nop_read();
 645 # else
 646     MISSING(AO_nop);
 647 # endif
 648 # if defined(AO_HAVE_store_read)
 649     AO_store_read(&x, 13);
 650     TA_assert (x == 13);
 651 # else
 652     MISSING(AO_store);
 653     x = 13;
 654 # endif
 655 # if defined(AO_HAVE_load_read)
 656     TA_assert(AO_load_read(&x) == 13);
 657 # else
 658     MISSING(AO_load);
 659 # endif
 660 # if defined(AO_HAVE_test_and_set_read)
 661     assert(AO_test_and_set_read(&z) == AO_TS_CLEAR);
 662     assert(AO_test_and_set_read(&z) == AO_TS_SET);
 663     assert(AO_test_and_set_read(&z) == AO_TS_SET);
 664     AO_CLEAR(&z);
 665 # else
 666     MISSING(AO_test_and_set);
 667 # endif
 668 # if defined(AO_HAVE_fetch_and_add_read)
 669     TA_assert(AO_fetch_and_add_read(&x, 42) == 13);
 670     TA_assert(AO_fetch_and_add_read(&x, -42) == 55);
 671 # else
 672     MISSING(AO_fetch_and_add);
 673 # endif
 674 # if defined(AO_HAVE_fetch_and_add1_read)
 675     TA_assert(AO_fetch_and_add1_read(&x) == 13);
 676 # else
 677     MISSING(AO_fetch_and_add1);
 678     ++x;
 679 # endif
 680 # if defined(AO_HAVE_fetch_and_sub1_read)
 681     TA_assert(AO_fetch_and_sub1_read(&x) == 14);
 682 # else
 683     MISSING(AO_fetch_and_sub1);
 684     --x;
 685 # endif
 686 # if defined(AO_HAVE_short_store_read)
 687     AO_short_store_read(&s, 13);
 688 # else
 689     MISSING(AO_short_store);
 690     s = 13;
 691 # endif
 692 # if defined(AO_HAVE_short_load_read)
 693     TA_assert(AO_short_load(&s) == 13);
 694 # else
 695     MISSING(AO_short_load);
 696 # endif
 697 # if defined(AO_HAVE_short_fetch_and_add_read)
 698     TA_assert(AO_short_fetch_and_add_read(&s, 42) == 13);
 699     TA_assert(AO_short_fetch_and_add_read(&s, -42) == 55);
 700 # else
 701     MISSING(AO_short_fetch_and_add);
 702 # endif
 703 # if defined(AO_HAVE_short_fetch_and_add1_read)
 704     TA_assert(AO_short_fetch_and_add1_read(&s) == 13);
 705 # else
 706     MISSING(AO_short_fetch_and_add1);
 707     ++s;
 708 # endif
 709 # if defined(AO_HAVE_short_fetch_and_sub1_read)
 710     TA_assert(AO_short_fetch_and_sub1_read(&s) == 14);
 711 # else
 712     MISSING(AO_short_fetch_and_sub1);
 713     --s;
 714 # endif
 715 # if defined(AO_HAVE_char_store_read)
 716     AO_char_store_read(&b, 13);
 717 # else
 718     MISSING(AO_char_store);
 719     b = 13;
 720 # endif
 721 # if defined(AO_HAVE_char_load_read)
 722     TA_assert(AO_char_load(&b) == 13);
 723 # else
 724     MISSING(AO_char_load);
 725 # endif
 726 # if defined(AO_HAVE_char_fetch_and_add_read)
 727     TA_assert(AO_char_fetch_and_add_read(&b, 42) == 13);
 728     TA_assert(AO_char_fetch_and_add_read(&b, -42) == 55);
 729 # else
 730     MISSING(AO_char_fetch_and_add);
 731 # endif
 732 # if defined(AO_HAVE_char_fetch_and_add1_read)
 733     TA_assert(AO_char_fetch_and_add1_read(&b) == 13);
 734 # else
 735     MISSING(AO_char_fetch_and_add1);
 736     ++b;
 737 # endif
 738 # if defined(AO_HAVE_char_fetch_and_sub1_read)
 739     TA_assert(AO_char_fetch_and_sub1_read(&b) == 14);
 740 # else
 741     MISSING(AO_char_fetch_and_sub1);
 742     --b;
 743 # endif
 744 # if defined(AO_HAVE_int_store_read)
 745     AO_int_store_read(&zz, 13);
 746 # else
 747     MISSING(AO_int_store);
 748     zz = 13;
 749 # endif
 750 # if defined(AO_HAVE_int_load_read)
 751     TA_assert(AO_int_load(&zz) == 13);
 752 # else
 753     MISSING(AO_int_load);
 754 # endif
 755 # if defined(AO_HAVE_int_fetch_and_add_read)
 756     TA_assert(AO_int_fetch_and_add_read(&zz, 42) == 13);
 757     TA_assert(AO_int_fetch_and_add_read(&zz, -42) == 55);
 758 # else
 759     MISSING(AO_int_fetch_and_add);
 760 # endif
 761 # if defined(AO_HAVE_int_fetch_and_add1_read)
 762     TA_assert(AO_int_fetch_and_add1_read(&zz) == 13);
 763 # else
 764     MISSING(AO_int_fetch_and_add1);
 765     ++zz;
 766 # endif
 767 # if defined(AO_HAVE_int_fetch_and_sub1_read)
 768     TA_assert(AO_int_fetch_and_sub1_read(&zz) == 14);
 769 # else
 770     MISSING(AO_int_fetch_and_sub1);
 771     --zz;
 772 # endif
 773 # if defined(AO_HAVE_compare_and_swap_read)
 774     TA_assert(!AO_compare_and_swap_read(&x, 14, 42));
 775     TA_assert(x == 13);
 776     TA_assert(AO_compare_and_swap_read(&x, 13, 42));
 777     TA_assert(x == 42);
 778 # else
 779     MISSING(AO_compare_and_swap);
 780 # endif
 781 # if defined(AO_HAVE_or_read)
 782     AO_or_read(&x, 66);
 783     TA_assert(x == 106);
 784 # else
 785     MISSING(AO_or);
 786     x |= 34;
 787 # endif
 788 # if defined(AO_HAVE_compare_double_and_swap_double_read)
 789     TA_assert(!AO_compare_double_and_swap_double_read(&w, 17, 42, 12, 13));
 790     TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 791     TA_assert(AO_compare_double_and_swap_double_read(&w, 0, 0, 12, 13));
 792     TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 793     TA_assert(AO_compare_double_and_swap_double_read(&w, 12, 13, 17, 42));
 794     TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 795     w.AO_val1 = 0; w.AO_val2 = 0;
 796 # else
 797     MISSING(AO_compare_double_and_swap_double);
 798 # endif
 799 # if defined(AO_HAVE_compare_and_swap_double_read)
 800     TA_assert(!AO_compare_and_swap_double_read(&w, 17, 12, 13));
 801     TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 802     TA_assert(AO_compare_and_swap_double_read(&w, 0, 12, 13));
 803     TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 804     TA_assert(AO_compare_and_swap_double_read(&w, 12, 17, 42));
 805     TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 806 # else
 807     MISSING(AO_compare_and_swap_double);
 808 # endif
 809 }
 810
 811
 812
 813 /*
 814  * Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
 815  *
 816  * This file is covered by the GNU general public license, version 2.
 817  * see doc/COPYING for details.
 818  */
 819
 820 /* Some basic sanity tests.  These do not test the barrier semantics. */
 821
 822 #undef TA_assert
 823 #define TA_assert(e) \
 824   if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: _write)\n", \
 825                     __FILE__, __LINE__), exit(1); }
 826
 827 #undef MISSING
 828 #define MISSING(name) \
 829   fprintf(stderr, "Missing: %s\n", #name "_write")
 830
 831 void test_atomic_write(void)
 832 {
 833   AO_t x;
 834   unsigned char b;
 835   unsigned short s;
 836   unsigned int zz;
 837 # if defined(AO_HAVE_test_and_set_write)
 838     AO_TS_t z = AO_TS_INITIALIZER;
 839 # endif
 840 # if defined(AO_HAVE_double_t)
 841     AO_double_t w;
 842     w.AO_val1 = 0;
 843     w.AO_val2 = 0;
 844 # endif
 845
 846 # if defined(AO_HAVE_nop_write)
 847     AO_nop_write();
 848 # else
 849     MISSING(AO_nop);
 850 # endif
 851 # if defined(AO_HAVE_store_write)
 852     AO_store_write(&x, 13);
 853     TA_assert (x == 13);
 854 # else
 855     MISSING(AO_store);
 856     x = 13;
 857 # endif
 858 # if defined(AO_HAVE_load_write)
 859     TA_assert(AO_load_write(&x) == 13);
 860 # else
 861     MISSING(AO_load);
 862 # endif
 863 # if defined(AO_HAVE_test_and_set_write)
 864     assert(AO_test_and_set_write(&z) == AO_TS_CLEAR);
 865     assert(AO_test_and_set_write(&z) == AO_TS_SET);
 866     assert(AO_test_and_set_write(&z) == AO_TS_SET);
 867     AO_CLEAR(&z);
 868 # else
 869     MISSING(AO_test_and_set);
 870 # endif
 871 # if defined(AO_HAVE_fetch_and_add_write)
 872     TA_assert(AO_fetch_and_add_write(&x, 42) == 13);
 873     TA_assert(AO_fetch_and_add_write(&x, -42) == 55);
 874 # else
 875     MISSING(AO_fetch_and_add);
 876 # endif
 877 # if defined(AO_HAVE_fetch_and_add1_write)
 878     TA_assert(AO_fetch_and_add1_write(&x) == 13);
 879 # else
 880     MISSING(AO_fetch_and_add1);
 881     ++x;
 882 # endif
 883 # if defined(AO_HAVE_fetch_and_sub1_write)
 884     TA_assert(AO_fetch_and_sub1_write(&x) == 14);
 885 # else
 886     MISSING(AO_fetch_and_sub1);
 887     --x;
 888 # endif
 889 # if defined(AO_HAVE_short_store_write)
 890     AO_short_store_write(&s, 13);
 891 # else
 892     MISSING(AO_short_store);
 893     s = 13;
 894 # endif
 895 # if defined(AO_HAVE_short_load_write)
 896     TA_assert(AO_short_load(&s) == 13);
 897 # else
 898     MISSING(AO_short_load);
 899 # endif
 900 # if defined(AO_HAVE_short_fetch_and_add_write)
 901     TA_assert(AO_short_fetch_and_add_write(&s, 42) == 13);
 902     TA_assert(AO_short_fetch_and_add_write(&s, -42) == 55);
 903 # else
 904     MISSING(AO_short_fetch_and_add);
 905 # endif
 906 # if defined(AO_HAVE_short_fetch_and_add1_write)
 907     TA_assert(AO_short_fetch_and_add1_write(&s) == 13);
 908 # else
 909     MISSING(AO_short_fetch_and_add1);
 910     ++s;
 911 # endif
 912 # if defined(AO_HAVE_short_fetch_and_sub1_write)
 913     TA_assert(AO_short_fetch_and_sub1_write(&s) == 14);
 914 # else
 915     MISSING(AO_short_fetch_and_sub1);
 916     --s;
 917 # endif
 918 # if defined(AO_HAVE_char_store_write)
 919     AO_char_store_write(&b, 13);
 920 # else
 921     MISSING(AO_char_store);
 922     b = 13;
 923 # endif
 924 # if defined(AO_HAVE_char_load_write)
 925     TA_assert(AO_char_load(&b) == 13);
 926 # else
 927     MISSING(AO_char_load);
 928 # endif
 929 # if defined(AO_HAVE_char_fetch_and_add_write)
 930     TA_assert(AO_char_fetch_and_add_write(&b, 42) == 13);
 931     TA_assert(AO_char_fetch_and_add_write(&b, -42) == 55);
 932 # else
 933     MISSING(AO_char_fetch_and_add);
 934 # endif
 935 # if defined(AO_HAVE_char_fetch_and_add1_write)
 936     TA_assert(AO_char_fetch_and_add1_write(&b) == 13);
 937 # else
 938     MISSING(AO_char_fetch_and_add1);
 939     ++b;
 940 # endif
 941 # if defined(AO_HAVE_char_fetch_and_sub1_write)
 942     TA_assert(AO_char_fetch_and_sub1_write(&b) == 14);
 943 # else
 944     MISSING(AO_char_fetch_and_sub1);
 945     --b;
 946 # endif
 947 # if defined(AO_HAVE_int_store_write)
 948     AO_int_store_write(&zz, 13);
 949 # else
 950     MISSING(AO_int_store);
 951     zz = 13;
 952 # endif
 953 # if defined(AO_HAVE_int_load_write)
 954     TA_assert(AO_int_load(&zz) == 13);
 955 # else
 956     MISSING(AO_int_load);
 957 # endif
 958 # if defined(AO_HAVE_int_fetch_and_add_write)
 959     TA_assert(AO_int_fetch_and_add_write(&zz, 42) == 13);
 960     TA_assert(AO_int_fetch_and_add_write(&zz, -42) == 55);
 961 # else
 962     MISSING(AO_int_fetch_and_add);
 963 # endif
 964 # if defined(AO_HAVE_int_fetch_and_add1_write)
 965     TA_assert(AO_int_fetch_and_add1_write(&zz) == 13);
 966 # else
 967     MISSING(AO_int_fetch_and_add1);
 968     ++zz;
 969 # endif
 970 # if defined(AO_HAVE_int_fetch_and_sub1_write)
 971     TA_assert(AO_int_fetch_and_sub1_write(&zz) == 14);
 972 # else
 973     MISSING(AO_int_fetch_and_sub1);
 974     --zz;
 975 # endif
 976 # if defined(AO_HAVE_compare_and_swap_write)
 977     TA_assert(!AO_compare_and_swap_write(&x, 14, 42));
 978     TA_assert(x == 13);
 979     TA_assert(AO_compare_and_swap_write(&x, 13, 42));
 980     TA_assert(x == 42);
 981 # else
 982     MISSING(AO_compare_and_swap);
 983 # endif
 984 # if defined(AO_HAVE_or_write)
 985     AO_or_write(&x, 66);
 986     TA_assert(x == 106);
 987 # else
 988     MISSING(AO_or);
 989     x |= 34;
 990 # endif
 991 # if defined(AO_HAVE_compare_double_and_swap_double_write)
 992     TA_assert(!AO_compare_double_and_swap_double_write(&w, 17, 42, 12, 13));
 993     TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
 994     TA_assert(AO_compare_double_and_swap_double_write(&w, 0, 0, 12, 13));
 995     TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
 996     TA_assert(AO_compare_double_and_swap_double_write(&w, 12, 13, 17, 42));
 997     TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
 998     w.AO_val1 = 0; w.AO_val2 = 0;
 999 # else
1000     MISSING(AO_compare_double_and_swap_double);
1001 # endif
1002 # if defined(AO_HAVE_compare_and_swap_double_write)
1003     TA_assert(!AO_compare_and_swap_double_write(&w, 17, 12, 13));
1004     TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
1005     TA_assert(AO_compare_and_swap_double_write(&w, 0, 12, 13));
1006     TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1007     TA_assert(AO_compare_and_swap_double_write(&w, 12, 17, 42));
1008     TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
1009 # else
1010     MISSING(AO_compare_and_swap_double);
1011 # endif
1012 }
1013
1014
1015
1016 /*
1017  * Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
1018  *
1019  * This file is covered by the GNU general public license, version 2.
1020  * see doc/COPYING for details.
1021  */
1022
1023 /* Some basic sanity tests.  These do not test the barrier semantics. */
1024
1025 #undef TA_assert
1026 #define TA_assert(e) \
1027   if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: _full)\n", \
1028                     __FILE__, __LINE__), exit(1); }
1029
1030 #undef MISSING
1031 #define MISSING(name) \
1032   fprintf(stderr, "Missing: %s\n", #name "_full")
1033
1034 void test_atomic_full(void)
1035 {
1036   AO_t x;
1037   unsigned char b;
1038   unsigned short s;
1039   unsigned int zz;
1040 # if defined(AO_HAVE_test_and_set_full)
1041     AO_TS_t z = AO_TS_INITIALIZER;
1042 # endif
1043 # if defined(AO_HAVE_double_t)
1044     AO_double_t w;
1045     w.AO_val1 = 0;
1046     w.AO_val2 = 0;
1047 # endif
1048
1049 # if defined(AO_HAVE_nop_full)
1050     AO_nop_full();
1051 # else
1052     MISSING(AO_nop);
1053 # endif
1054 # if defined(AO_HAVE_store_full)
1055     AO_store_full(&x, 13);
1056     TA_assert (x == 13);
1057 # else
1058     MISSING(AO_store);
1059     x = 13;
1060 # endif
1061 # if defined(AO_HAVE_load_full)
1062     TA_assert(AO_load_full(&x) == 13);
1063 # else
1064     MISSING(AO_load);
1065 # endif
1066 # if defined(AO_HAVE_test_and_set_full)
1067     assert(AO_test_and_set_full(&z) == AO_TS_CLEAR);
1068     assert(AO_test_and_set_full(&z) == AO_TS_SET);
1069     assert(AO_test_and_set_full(&z) == AO_TS_SET);
1070     AO_CLEAR(&z);
1071 # else
1072     MISSING(AO_test_and_set);
1073 # endif
1074 # if defined(AO_HAVE_fetch_and_add_full)
1075     TA_assert(AO_fetch_and_add_full(&x, 42) == 13);
1076     TA_assert(AO_fetch_and_add_full(&x, -42) == 55);
1077 # else
1078     MISSING(AO_fetch_and_add);
1079 # endif
1080 # if defined(AO_HAVE_fetch_and_add1_full)
1081     TA_assert(AO_fetch_and_add1_full(&x) == 13);
1082 # else
1083     MISSING(AO_fetch_and_add1);
1084     ++x;
1085 # endif
1086 # if defined(AO_HAVE_fetch_and_sub1_full)
1087     TA_assert(AO_fetch_and_sub1_full(&x) == 14);
1088 # else
1089     MISSING(AO_fetch_and_sub1);
1090     --x;
1091 # endif
1092 # if defined(AO_HAVE_short_store_full)
1093     AO_short_store_full(&s, 13);
1094 # else
1095     MISSING(AO_short_store);
1096     s = 13;
1097 # endif
1098 # if defined(AO_HAVE_short_load_full)
1099     TA_assert(AO_short_load(&s) == 13);
1100 # else
1101     MISSING(AO_short_load);
1102 # endif
1103 # if defined(AO_HAVE_short_fetch_and_add_full)
1104     TA_assert(AO_short_fetch_and_add_full(&s, 42) == 13);
1105     TA_assert(AO_short_fetch_and_add_full(&s, -42) == 55);
1106 # else
1107     MISSING(AO_short_fetch_and_add);
1108 # endif
1109 # if defined(AO_HAVE_short_fetch_and_add1_full)
1110     TA_assert(AO_short_fetch_and_add1_full(&s) == 13);
1111 # else
1112     MISSING(AO_short_fetch_and_add1);
1113     ++s;
1114 # endif
1115 # if defined(AO_HAVE_short_fetch_and_sub1_full)
1116     TA_assert(AO_short_fetch_and_sub1_full(&s) == 14);
1117 # else
1118     MISSING(AO_short_fetch_and_sub1);
1119     --s;
1120 # endif
1121 # if defined(AO_HAVE_char_store_full)
1122     AO_char_store_full(&b, 13);
1123 # else
1124     MISSING(AO_char_store);
1125     b = 13;
1126 # endif
1127 # if defined(AO_HAVE_char_load_full)
1128     TA_assert(AO_char_load(&b) == 13);
1129 # else
1130     MISSING(AO_char_load);
1131 # endif
1132 # if defined(AO_HAVE_char_fetch_and_add_full)
1133     TA_assert(AO_char_fetch_and_add_full(&b, 42) == 13);
1134     TA_assert(AO_char_fetch_and_add_full(&b, -42) == 55);
1135 # else
1136     MISSING(AO_char_fetch_and_add);
1137 # endif
1138 # if defined(AO_HAVE_char_fetch_and_add1_full)
1139     TA_assert(AO_char_fetch_and_add1_full(&b) == 13);
1140 # else
1141     MISSING(AO_char_fetch_and_add1);
1142     ++b;
1143 # endif
1144 # if defined(AO_HAVE_char_fetch_and_sub1_full)
1145     TA_assert(AO_char_fetch_and_sub1_full(&b) == 14);
1146 # else
1147     MISSING(AO_char_fetch_and_sub1);
1148     --b;
1149 # endif
1150 # if defined(AO_HAVE_int_store_full)
1151     AO_int_store_full(&zz, 13);
1152 # else
1153     MISSING(AO_int_store);
1154     zz = 13;
1155 # endif
1156 # if defined(AO_HAVE_int_load_full)
1157     TA_assert(AO_int_load(&zz) == 13);
1158 # else
1159     MISSING(AO_int_load);
1160 # endif
1161 # if defined(AO_HAVE_int_fetch_and_add_full)
1162     TA_assert(AO_int_fetch_and_add_full(&zz, 42) == 13);
1163     TA_assert(AO_int_fetch_and_add_full(&zz, -42) == 55);
1164 # else
1165     MISSING(AO_int_fetch_and_add);
1166 # endif
1167 # if defined(AO_HAVE_int_fetch_and_add1_full)
1168     TA_assert(AO_int_fetch_and_add1_full(&zz) == 13);
1169 # else
1170     MISSING(AO_int_fetch_and_add1);
1171     ++zz;
1172 # endif
1173 # if defined(AO_HAVE_int_fetch_and_sub1_full)
1174     TA_assert(AO_int_fetch_and_sub1_full(&zz) == 14);
1175 # else
1176     MISSING(AO_int_fetch_and_sub1);
1177     --zz;
1178 # endif
1179 # if defined(AO_HAVE_compare_and_swap_full)
1180     TA_assert(!AO_compare_and_swap_full(&x, 14, 42));
1181     TA_assert(x == 13);
1182     TA_assert(AO_compare_and_swap_full(&x, 13, 42));
1183     TA_assert(x == 42);
1184 # else
1185     MISSING(AO_compare_and_swap);
1186 # endif
1187 # if defined(AO_HAVE_or_full)
1188     AO_or_full(&x, 66);
1189     TA_assert(x == 106);
1190 # else
1191     MISSING(AO_or);
1192     x |= 34;
1193 # endif
1194 # if defined(AO_HAVE_compare_double_and_swap_double_full)
1195     TA_assert(!AO_compare_double_and_swap_double_full(&w, 17, 42, 12, 13));
1196     TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
1197     TA_assert(AO_compare_double_and_swap_double_full(&w, 0, 0, 12, 13));
1198     TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1199     TA_assert(AO_compare_double_and_swap_double_full(&w, 12, 13, 17, 42));
1200     TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
1201     w.AO_val1 = 0; w.AO_val2 = 0;
1202 # else
1203     MISSING(AO_compare_double_and_swap_double);
1204 # endif
1205 # if defined(AO_HAVE_compare_and_swap_double_full)
1206     TA_assert(!AO_compare_and_swap_double_full(&w, 17, 12, 13));
1207     TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
1208     TA_assert(AO_compare_and_swap_double_full(&w, 0, 12, 13));
1209     TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1210     TA_assert(AO_compare_and_swap_double_full(&w, 12, 17, 42));
1211     TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
1212 # else
1213     MISSING(AO_compare_and_swap_double);
1214 # endif
1215 }
1216
1217
1218
1219 /*
1220  * Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
1221  *
1222  * This file is covered by the GNU general public license, version 2.
1223  * see doc/COPYING for details.
1224  */
1225
1226 /* Some basic sanity tests.  These do not test the barrier semantics. */
1227
1228 #undef TA_assert
1229 #define TA_assert(e) \
1230   if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: _release_write)\n", \
1231                     __FILE__, __LINE__), exit(1); }
1232
1233 #undef MISSING
1234 #define MISSING(name) \
1235   fprintf(stderr, "Missing: %s\n", #name "_release_write")
1236
1237 void test_atomic_release_write(void)
1238 {
1239   AO_t x;
1240   unsigned char b;
1241   unsigned short s;
1242   unsigned int zz;
1243 # if defined(AO_HAVE_test_and_set_release_write)
1244     AO_TS_t z = AO_TS_INITIALIZER;
1245 # endif
1246 # if defined(AO_HAVE_double_t)
1247     AO_double_t w;
1248     w.AO_val1 = 0;
1249     w.AO_val2 = 0;
1250 # endif
1251
1252 # if defined(AO_HAVE_nop_release_write)
1253     AO_nop_release_write();
1254 # else
1255     MISSING(AO_nop);
1256 # endif
1257 # if defined(AO_HAVE_store_release_write)
1258     AO_store_release_write(&x, 13);
1259     TA_assert (x == 13);
1260 # else
1261     MISSING(AO_store);
1262     x = 13;
1263 # endif
1264 # if defined(AO_HAVE_load_release_write)
1265     TA_assert(AO_load_release_write(&x) == 13);
1266 # else
1267     MISSING(AO_load);
1268 # endif
1269 # if defined(AO_HAVE_test_and_set_release_write)
1270     assert(AO_test_and_set_release_write(&z) == AO_TS_CLEAR);
1271     assert(AO_test_and_set_release_write(&z) == AO_TS_SET);
1272     assert(AO_test_and_set_release_write(&z) == AO_TS_SET);
1273     AO_CLEAR(&z);
1274 # else
1275     MISSING(AO_test_and_set);
1276 # endif
1277 # if defined(AO_HAVE_fetch_and_add_release_write)
1278     TA_assert(AO_fetch_and_add_release_write(&x, 42) == 13);
1279     TA_assert(AO_fetch_and_add_release_write(&x, -42) == 55);
1280 # else
1281     MISSING(AO_fetch_and_add);
1282 # endif
1283 # if defined(AO_HAVE_fetch_and_add1_release_write)
1284     TA_assert(AO_fetch_and_add1_release_write(&x) == 13);
1285 # else
1286     MISSING(AO_fetch_and_add1);
1287     ++x;
1288 # endif
1289 # if defined(AO_HAVE_fetch_and_sub1_release_write)
1290     TA_assert(AO_fetch_and_sub1_release_write(&x) == 14);
1291 # else
1292     MISSING(AO_fetch_and_sub1);
1293     --x;
1294 # endif
1295 # if defined(AO_HAVE_short_store_release_write)
1296     AO_short_store_release_write(&s, 13);
1297 # else
1298     MISSING(AO_short_store);
1299     s = 13;
1300 # endif
1301 # if defined(AO_HAVE_short_load_release_write)
1302     TA_assert(AO_short_load(&s) == 13);
1303 # else
1304     MISSING(AO_short_load);
1305 # endif
1306 # if defined(AO_HAVE_short_fetch_and_add_release_write)
1307     TA_assert(AO_short_fetch_and_add_release_write(&s, 42) == 13);
1308     TA_assert(AO_short_fetch_and_add_release_write(&s, -42) == 55);
1309 # else
1310     MISSING(AO_short_fetch_and_add);
1311 # endif
1312 # if defined(AO_HAVE_short_fetch_and_add1_release_write)
1313     TA_assert(AO_short_fetch_and_add1_release_write(&s) == 13);
1314 # else
1315     MISSING(AO_short_fetch_and_add1);
1316     ++s;
1317 # endif
1318 # if defined(AO_HAVE_short_fetch_and_sub1_release_write)
1319     TA_assert(AO_short_fetch_and_sub1_release_write(&s) == 14);
1320 # else
1321     MISSING(AO_short_fetch_and_sub1);
1322     --s;
1323 # endif
1324 # if defined(AO_HAVE_char_store_release_write)
1325     AO_char_store_release_write(&b, 13);
1326 # else
1327     MISSING(AO_char_store);
1328     b = 13;
1329 # endif
1330 # if defined(AO_HAVE_char_load_release_write)
1331     TA_assert(AO_char_load(&b) == 13);
1332 # else
1333     MISSING(AO_char_load);
1334 # endif
1335 # if defined(AO_HAVE_char_fetch_and_add_release_write)
1336     TA_assert(AO_char_fetch_and_add_release_write(&b, 42) == 13);
1337     TA_assert(AO_char_fetch_and_add_release_write(&b, -42) == 55);
1338 # else
1339     MISSING(AO_char_fetch_and_add);
1340 # endif
1341 # if defined(AO_HAVE_char_fetch_and_add1_release_write)
1342     TA_assert(AO_char_fetch_and_add1_release_write(&b) == 13);
1343 # else
1344     MISSING(AO_char_fetch_and_add1);
1345     ++b;
1346 # endif
1347 # if defined(AO_HAVE_char_fetch_and_sub1_release_write)
1348     TA_assert(AO_char_fetch_and_sub1_release_write(&b) == 14);
1349 # else
1350     MISSING(AO_char_fetch_and_sub1);
1351     --b;
1352 # endif
1353 # if defined(AO_HAVE_int_store_release_write)
1354     AO_int_store_release_write(&zz, 13);
1355 # else
1356     MISSING(AO_int_store);
1357     zz = 13;
1358 # endif
1359 # if defined(AO_HAVE_int_load_release_write)
1360     TA_assert(AO_int_load(&zz) == 13);
1361 # else
1362     MISSING(AO_int_load);
1363 # endif
1364 # if defined(AO_HAVE_int_fetch_and_add_release_write)
1365     TA_assert(AO_int_fetch_and_add_release_write(&zz, 42) == 13);
1366     TA_assert(AO_int_fetch_and_add_release_write(&zz, -42) == 55);
1367 # else
1368     MISSING(AO_int_fetch_and_add);
1369 # endif
1370 # if defined(AO_HAVE_int_fetch_and_add1_release_write)
1371     TA_assert(AO_int_fetch_and_add1_release_write(&zz) == 13);
1372 # else
1373     MISSING(AO_int_fetch_and_add1);
1374     ++zz;
1375 # endif
1376 # if defined(AO_HAVE_int_fetch_and_sub1_release_write)
1377     TA_assert(AO_int_fetch_and_sub1_release_write(&zz) == 14);
1378 # else
1379     MISSING(AO_int_fetch_and_sub1);
1380     --zz;
1381 # endif
1382 # if defined(AO_HAVE_compare_and_swap_release_write)
1383     TA_assert(!AO_compare_and_swap_release_write(&x, 14, 42));
1384     TA_assert(x == 13);
1385     TA_assert(AO_compare_and_swap_release_write(&x, 13, 42));
1386     TA_assert(x == 42);
1387 # else
1388     MISSING(AO_compare_and_swap);
1389 # endif
1390 # if defined(AO_HAVE_or_release_write)
1391     AO_or_release_write(&x, 66);
1392     TA_assert(x == 106);
1393 # else
1394     MISSING(AO_or);
1395     x |= 34;
1396 # endif
1397 # if defined(AO_HAVE_compare_double_and_swap_double_release_write)
1398     TA_assert(!AO_compare_double_and_swap_double_release_write(&w, 17, 42, 12, 13));
1399     TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
1400     TA_assert(AO_compare_double_and_swap_double_release_write(&w, 0, 0, 12, 13));
1401     TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1402     TA_assert(AO_compare_double_and_swap_double_release_write(&w, 12, 13, 17, 42));
1403     TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
1404     w.AO_val1 = 0; w.AO_val2 = 0;
1405 # else
1406     MISSING(AO_compare_double_and_swap_double);
1407 # endif
1408 # if defined(AO_HAVE_compare_and_swap_double_release_write)
1409     TA_assert(!AO_compare_and_swap_double_release_write(&w, 17, 12, 13));
1410     TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
1411     TA_assert(AO_compare_and_swap_double_release_write(&w, 0, 12, 13));
1412     TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1413     TA_assert(AO_compare_and_swap_double_release_write(&w, 12, 17, 42));
1414     TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
1415 # else
1416     MISSING(AO_compare_and_swap_double);
1417 # endif
1418 }
1419
1420
1421
1422 /*
1423  * Copyright (c) 2003 by Hewlett-Packard Company.  All rights reserved.
1424  *
1425  * This file is covered by the GNU general public license, version 2.
1426  * see doc/COPYING for details.
1427  */
1428
1429 /* Some basic sanity tests.  These do not test the barrier semantics. */
1430
1431 #undef TA_assert
1432 #define TA_assert(e) \
1433   if (!(e)) { fprintf(stderr, "Assertion failed %s:%d (barrier: _acquire_read)\n", \
1434                     __FILE__, __LINE__), exit(1); }
1435
1436 #undef MISSING
1437 #define MISSING(name) \
1438   fprintf(stderr, "Missing: %s\n", #name "_acquire_read")
1439
1440 void test_atomic_acquire_read(void)
1441 {
1442   AO_t x;
1443   unsigned char b;
1444   unsigned short s;
1445   unsigned int zz;
1446 # if defined(AO_HAVE_test_and_set_acquire_read)
1447     AO_TS_t z = AO_TS_INITIALIZER;
1448 # endif
1449 # if defined(AO_HAVE_double_t)
1450     AO_double_t w;
1451     w.AO_val1 = 0;
1452     w.AO_val2 = 0;
1453 # endif
1454
1455 # if defined(AO_HAVE_nop_acquire_read)
1456     AO_nop_acquire_read();
1457 # else
1458     MISSING(AO_nop);
1459 # endif
1460 # if defined(AO_HAVE_store_acquire_read)
1461     AO_store_acquire_read(&x, 13);
1462     TA_assert (x == 13);
1463 # else
1464     MISSING(AO_store);
1465     x = 13;
1466 # endif
1467 # if defined(AO_HAVE_load_acquire_read)
1468     TA_assert(AO_load_acquire_read(&x) == 13);
1469 # else
1470     MISSING(AO_load);
1471 # endif
1472 # if defined(AO_HAVE_test_and_set_acquire_read)
1473     assert(AO_test_and_set_acquire_read(&z) == AO_TS_CLEAR);
1474     assert(AO_test_and_set_acquire_read(&z) == AO_TS_SET);
1475     assert(AO_test_and_set_acquire_read(&z) == AO_TS_SET);
1476     AO_CLEAR(&z);
1477 # else
1478     MISSING(AO_test_and_set);
1479 # endif
1480 # if defined(AO_HAVE_fetch_and_add_acquire_read)
1481     TA_assert(AO_fetch_and_add_acquire_read(&x, 42) == 13);
1482     TA_assert(AO_fetch_and_add_acquire_read(&x, -42) == 55);
1483 # else
1484     MISSING(AO_fetch_and_add);
1485 # endif
1486 # if defined(AO_HAVE_fetch_and_add1_acquire_read)
1487     TA_assert(AO_fetch_and_add1_acquire_read(&x) == 13);
1488 # else
1489     MISSING(AO_fetch_and_add1);
1490     ++x;
1491 # endif
1492 # if defined(AO_HAVE_fetch_and_sub1_acquire_read)
1493     TA_assert(AO_fetch_and_sub1_acquire_read(&x) == 14);
1494 # else
1495     MISSING(AO_fetch_and_sub1);
1496     --x;
1497 # endif
1498 # if defined(AO_HAVE_short_store_acquire_read)
1499     AO_short_store_acquire_read(&s, 13);
1500 # else
1501     MISSING(AO_short_store);
1502     s = 13;
1503 # endif
1504 # if defined(AO_HAVE_short_load_acquire_read)
1505     TA_assert(AO_short_load(&s) == 13);
1506 # else
1507     MISSING(AO_short_load);
1508 # endif
1509 # if defined(AO_HAVE_short_fetch_and_add_acquire_read)
1510     TA_assert(AO_short_fetch_and_add_acquire_read(&s, 42) == 13);
1511     TA_assert(AO_short_fetch_and_add_acquire_read(&s, -42) == 55);
1512 # else
1513     MISSING(AO_short_fetch_and_add);
1514 # endif
1515 # if defined(AO_HAVE_short_fetch_and_add1_acquire_read)
1516     TA_assert(AO_short_fetch_and_add1_acquire_read(&s) == 13);
1517 # else
1518     MISSING(AO_short_fetch_and_add1);
1519     ++s;
1520 # endif
1521 # if defined(AO_HAVE_short_fetch_and_sub1_acquire_read)
1522     TA_assert(AO_short_fetch_and_sub1_acquire_read(&s) == 14);
1523 # else
1524     MISSING(AO_short_fetch_and_sub1);
1525     --s;
1526 # endif
1527 # if defined(AO_HAVE_char_store_acquire_read)
1528     AO_char_store_acquire_read(&b, 13);
1529 # else
1530     MISSING(AO_char_store);
1531     b = 13;
1532 # endif
1533 # if defined(AO_HAVE_char_load_acquire_read)
1534     TA_assert(AO_char_load(&b) == 13);
1535 # else
1536     MISSING(AO_char_load);
1537 # endif
1538 # if defined(AO_HAVE_char_fetch_and_add_acquire_read)
1539     TA_assert(AO_char_fetch_and_add_acquire_read(&b, 42) == 13);
1540     TA_assert(AO_char_fetch_and_add_acquire_read(&b, -42) == 55);
1541 # else
1542     MISSING(AO_char_fetch_and_add);
1543 # endif
1544 # if defined(AO_HAVE_char_fetch_and_add1_acquire_read)
1545     TA_assert(AO_char_fetch_and_add1_acquire_read(&b) == 13);
1546 # else
1547     MISSING(AO_char_fetch_and_add1);
1548     ++b;
1549 # endif
1550 # if defined(AO_HAVE_char_fetch_and_sub1_acquire_read)
1551     TA_assert(AO_char_fetch_and_sub1_acquire_read(&b) == 14);
1552 # else
1553     MISSING(AO_char_fetch_and_sub1);
1554     --b;
1555 # endif
1556 # if defined(AO_HAVE_int_store_acquire_read)
1557     AO_int_store_acquire_read(&zz, 13);
1558 # else
1559     MISSING(AO_int_store);
1560     zz = 13;
1561 # endif
1562 # if defined(AO_HAVE_int_load_acquire_read)
1563     TA_assert(AO_int_load(&zz) == 13);
1564 # else
1565     MISSING(AO_int_load);
1566 # endif
1567 # if defined(AO_HAVE_int_fetch_and_add_acquire_read)
1568     TA_assert(AO_int_fetch_and_add_acquire_read(&zz, 42) == 13);
1569     TA_assert(AO_int_fetch_and_add_acquire_read(&zz, -42) == 55);
1570 # else
1571     MISSING(AO_int_fetch_and_add);
1572 # endif
1573 # if defined(AO_HAVE_int_fetch_and_add1_acquire_read)
1574     TA_assert(AO_int_fetch_and_add1_acquire_read(&zz) == 13);
1575 # else
1576     MISSING(AO_int_fetch_and_add1);
1577     ++zz;
1578 # endif
1579 # if defined(AO_HAVE_int_fetch_and_sub1_acquire_read)
1580     TA_assert(AO_int_fetch_and_sub1_acquire_read(&zz) == 14);
1581 # else
1582     MISSING(AO_int_fetch_and_sub1);
1583     --zz;
1584 # endif
1585 # if defined(AO_HAVE_compare_and_swap_acquire_read)
1586     TA_assert(!AO_compare_and_swap_acquire_read(&x, 14, 42));
1587     TA_assert(x == 13);
1588     TA_assert(AO_compare_and_swap_acquire_read(&x, 13, 42));
1589     TA_assert(x == 42);
1590 # else
1591     MISSING(AO_compare_and_swap);
1592 # endif
1593 # if defined(AO_HAVE_or_acquire_read)
1594     AO_or_acquire_read(&x, 66);
1595     TA_assert(x == 106);
1596 # else
1597     MISSING(AO_or);
1598     x |= 34;
1599 # endif
1600 # if defined(AO_HAVE_compare_double_and_swap_double_acquire_read)
1601     TA_assert(!AO_compare_double_and_swap_double_acquire_read(&w, 17, 42, 12, 13));
1602     TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
1603     TA_assert(AO_compare_double_and_swap_double_acquire_read(&w, 0, 0, 12, 13));
1604     TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1605     TA_assert(AO_compare_double_and_swap_double_acquire_read(&w, 12, 13, 17, 42));
1606     TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
1607     w.AO_val1 = 0; w.AO_val2 = 0;
1608 # else
1609     MISSING(AO_compare_double_and_swap_double);
1610 # endif
1611 # if defined(AO_HAVE_compare_and_swap_double_acquire_read)
1612     TA_assert(!AO_compare_and_swap_double_acquire_read(&w, 17, 12, 13));
1613     TA_assert(w.AO_val1 == 0 && w.AO_val2 == 0);
1614     TA_assert(AO_compare_and_swap_double_acquire_read(&w, 0, 12, 13));
1615     TA_assert(w.AO_val1 == 12 && w.AO_val2 == 13);
1616     TA_assert(AO_compare_and_swap_double_acquire_read(&w, 12, 17, 42));
1617     TA_assert(w.AO_val1 == 17 && w.AO_val2 == 42);
1618 # else
1619     MISSING(AO_compare_and_swap_double);
1620 # endif
1621 }
1622
1623
1624