gcc/testsuite/gcc.dg/atomic-op-2.c

   1 /* Test __atomic routines for existence and proper execution on 2 byte
   2    values with each valid memory model.  */
   3 /* { dg-do run } */
   4 /* { dg-require-effective-target sync_char_short } */
   5
   6
   7 /* Test the execution of the __atomic_*OP builtin routines for a short.  */
   8
   9 extern void abort(void);
  10
  11 short v, count, res;
  12 const short init = ~0;
  13
  14 /* The fetch_op routines return the original value before the operation.  */
  15
  16 void
  17 test_fetch_add ()
  18 {
  19   v = 0;
  20   count = 1;
  21
  22   if (__atomic_fetch_add (&v, count, __ATOMIC_RELAXED) != 0)
  23     abort ();
  24
  25   if (__atomic_fetch_add (&v, 1, __ATOMIC_CONSUME) != 1)
  26     abort ();
  27
  28   if (__atomic_fetch_add (&v, count, __ATOMIC_ACQUIRE) != 2)
  29     abort ();
  30
  31   if (__atomic_fetch_add (&v, 1, __ATOMIC_RELEASE) != 3)
  32     abort ();
  33
  34   if (__atomic_fetch_add (&v, count, __ATOMIC_ACQ_REL) != 4)
  35     abort ();
  36
  37   if (__atomic_fetch_add (&v, 1, __ATOMIC_SEQ_CST) != 5)
  38     abort ();
  39 }
  40
  41
  42 void
  43 test_fetch_sub()
  44 {
  45   v = res = 20;
  46   count = 0;
  47
  48   if (__atomic_fetch_sub (&v, count + 1, __ATOMIC_RELAXED) !=  res--)
  49     abort ();
  50
  51   if (__atomic_fetch_sub (&v, 1, __ATOMIC_CONSUME) !=  res--)
  52     abort ();
  53
  54   if (__atomic_fetch_sub (&v, count + 1, __ATOMIC_ACQUIRE) !=  res--)
  55     abort ();
  56
  57   if (__atomic_fetch_sub (&v, 1, __ATOMIC_RELEASE) !=  res--)
  58     abort ();
  59
  60   if (__atomic_fetch_sub (&v, count + 1, __ATOMIC_ACQ_REL) !=  res--)
  61     abort ();
  62
  63   if (__atomic_fetch_sub (&v, 1, __ATOMIC_SEQ_CST) !=  res--)
  64     abort ();
  65 }
  66
  67 void
  68 test_fetch_and ()
  69 {
  70   v = init;
  71
  72   if (__atomic_fetch_and (&v, 0, __ATOMIC_RELAXED) !=  init)
  73     abort ();
  74
  75   if (__atomic_fetch_and (&v, init, __ATOMIC_CONSUME) !=  0)
  76     abort ();
  77
  78   if (__atomic_fetch_and (&v, 0, __ATOMIC_ACQUIRE) !=  0)
  79     abort ();
  80
  81   v = ~v;
  82   if (__atomic_fetch_and (&v, init, __ATOMIC_RELEASE) !=  init)
  83     abort ();
  84
  85   if (__atomic_fetch_and (&v, 0, __ATOMIC_ACQ_REL) !=  init)
  86     abort ();
  87
  88   if (__atomic_fetch_and (&v, 0, __ATOMIC_SEQ_CST) !=  0)
  89     abort ();
  90 }
  91
  92 void
  93 test_fetch_nand ()
  94 {
  95   v = init;
  96
  97   if (__atomic_fetch_nand (&v, 0, __ATOMIC_RELAXED) !=  init)
  98     abort ();
  99
 100   if (__atomic_fetch_nand (&v, init, __ATOMIC_CONSUME) !=  init)
 101     abort ();
 102
 103   if (__atomic_fetch_nand (&v, 0, __ATOMIC_ACQUIRE) !=  0 )
 104     abort ();
 105
 106   if (__atomic_fetch_nand (&v, init, __ATOMIC_RELEASE) !=  init)
 107     abort ();
 108
 109   if (__atomic_fetch_nand (&v, init, __ATOMIC_ACQ_REL) !=  0)
 110     abort ();
 111
 112   if (__atomic_fetch_nand (&v, 0, __ATOMIC_SEQ_CST) !=  init)
 113     abort ();
 114 }
 115
 116 void
 117 test_fetch_xor ()
 118 {
 119   v = init;
 120   count = 0;
 121
 122   if (__atomic_fetch_xor (&v, count, __ATOMIC_RELAXED) !=  init)
 123     abort ();
 124
 125   if (__atomic_fetch_xor (&v, ~count, __ATOMIC_CONSUME) !=  init)
 126     abort ();
 127
 128   if (__atomic_fetch_xor (&v, 0, __ATOMIC_ACQUIRE) !=  0)
 129     abort ();
 130
 131   if (__atomic_fetch_xor (&v, ~count, __ATOMIC_RELEASE) !=  0)
 132     abort ();
 133
 134   if (__atomic_fetch_xor (&v, 0, __ATOMIC_ACQ_REL) !=  init)
 135     abort ();
 136
 137   if (__atomic_fetch_xor (&v, ~count, __ATOMIC_SEQ_CST) !=  init)
 138     abort ();
 139 }
 140
 141 void
 142 test_fetch_or ()
 143 {
 144   v = 0;
 145   count = 1;
 146
 147   if (__atomic_fetch_or (&v, count, __ATOMIC_RELAXED) !=  0)
 148     abort ();
 149
 150   count *= 2;
 151   if (__atomic_fetch_or (&v, 2, __ATOMIC_CONSUME) !=  1)
 152     abort ();
 153
 154   count *= 2;
 155   if (__atomic_fetch_or (&v, count, __ATOMIC_ACQUIRE) !=  3)
 156     abort ();
 157
 158   count *= 2;
 159   if (__atomic_fetch_or (&v, 8, __ATOMIC_RELEASE) !=  7)
 160     abort ();
 161
 162   count *= 2;
 163   if (__atomic_fetch_or (&v, count, __ATOMIC_ACQ_REL) !=  15)
 164     abort ();
 165
 166   count *= 2;
 167   if (__atomic_fetch_or (&v, count, __ATOMIC_SEQ_CST) !=  31)
 168     abort ();
 169 }
 170
 171 /* The OP_fetch routines return the new value after the operation.  */
 172
 173 void
 174 test_add_fetch ()
 175 {
 176   v = 0;
 177   count = 1;
 178
 179   if (__atomic_add_fetch (&v, count, __ATOMIC_RELAXED) != 1)
 180     abort ();
 181
 182   if (__atomic_add_fetch (&v, 1, __ATOMIC_CONSUME) != 2)
 183     abort ();
 184
 185   if (__atomic_add_fetch (&v, count, __ATOMIC_ACQUIRE) != 3)
 186     abort ();
 187
 188   if (__atomic_add_fetch (&v, 1, __ATOMIC_RELEASE) != 4)
 189     abort ();
 190
 191   if (__atomic_add_fetch (&v, count, __ATOMIC_ACQ_REL) != 5)
 192     abort ();
 193
 194   if (__atomic_add_fetch (&v, count, __ATOMIC_SEQ_CST) != 6)
 195     abort ();
 196 }
 197
 198
 199 void
 200 test_sub_fetch ()
 201 {
 202   v = res = 20;
 203   count = 0;
 204
 205   if (__atomic_sub_fetch (&v, count + 1, __ATOMIC_RELAXED) !=  --res)
 206     abort ();
 207
 208   if (__atomic_sub_fetch (&v, 1, __ATOMIC_CONSUME) !=  --res)
 209     abort ();
 210
 211   if (__atomic_sub_fetch (&v, count + 1, __ATOMIC_ACQUIRE) !=  --res)
 212     abort ();
 213
 214   if (__atomic_sub_fetch (&v, 1, __ATOMIC_RELEASE) !=  --res)
 215     abort ();
 216
 217   if (__atomic_sub_fetch (&v, count + 1, __ATOMIC_ACQ_REL) !=  --res)
 218     abort ();
 219
 220   if (__atomic_sub_fetch (&v, count + 1, __ATOMIC_SEQ_CST) !=  --res)
 221     abort ();
 222 }
 223
 224 void
 225 test_and_fetch ()
 226 {
 227   v = init;
 228
 229   if (__atomic_and_fetch (&v, 0, __ATOMIC_RELAXED) !=  0)
 230     abort ();
 231
 232   v = init;
 233   if (__atomic_and_fetch (&v, init, __ATOMIC_CONSUME) !=  init)
 234     abort ();
 235
 236   if (__atomic_and_fetch (&v, 0, __ATOMIC_ACQUIRE) !=  0)
 237     abort ();
 238
 239   v = ~v;
 240   if (__atomic_and_fetch (&v, init, __ATOMIC_RELEASE) !=  init)
 241     abort ();
 242
 243   if (__atomic_and_fetch (&v, 0, __ATOMIC_ACQ_REL) !=  0)
 244     abort ();
 245
 246   v = ~v;
 247   if (__atomic_and_fetch (&v, 0, __ATOMIC_SEQ_CST) !=  0)
 248     abort ();
 249 }
 250
 251 void
 252 test_nand_fetch ()
 253 {
 254   v = init;
 255
 256   if (__atomic_nand_fetch (&v, 0, __ATOMIC_RELAXED) !=  init)
 257     abort ();
 258
 259   if (__atomic_nand_fetch (&v, init, __ATOMIC_CONSUME) !=  0)
 260     abort ();
 261
 262   if (__atomic_nand_fetch (&v, 0, __ATOMIC_ACQUIRE) !=  init)
 263     abort ();
 264
 265   if (__atomic_nand_fetch (&v, init, __ATOMIC_RELEASE) !=  0)
 266     abort ();
 267
 268   if (__atomic_nand_fetch (&v, init, __ATOMIC_ACQ_REL) !=  init)
 269     abort ();
 270
 271   if (__atomic_nand_fetch (&v, 0, __ATOMIC_SEQ_CST) !=  init)
 272     abort ();
 273 }
 274
 275
 276
 277 void
 278 test_xor_fetch ()
 279 {
 280   v = init;
 281   count = 0;
 282
 283   if (__atomic_xor_fetch (&v, count, __ATOMIC_RELAXED) !=  init)
 284     abort ();
 285
 286   if (__atomic_xor_fetch (&v, ~count, __ATOMIC_CONSUME) !=  0)
 287     abort ();
 288
 289   if (__atomic_xor_fetch (&v, 0, __ATOMIC_ACQUIRE) !=  0)
 290     abort ();
 291
 292   if (__atomic_xor_fetch (&v, ~count, __ATOMIC_RELEASE) !=  init)
 293     abort ();
 294
 295   if (__atomic_xor_fetch (&v, 0, __ATOMIC_ACQ_REL) !=  init)
 296     abort ();
 297
 298   if (__atomic_xor_fetch (&v, ~count, __ATOMIC_SEQ_CST) !=  0)
 299     abort ();
 300 }
 301
 302 void
 303 test_or_fetch ()
 304 {
 305   v = 0;
 306   count = 1;
 307
 308   if (__atomic_or_fetch (&v, count, __ATOMIC_RELAXED) !=  1)
 309     abort ();
 310
 311   count *= 2;
 312   if (__atomic_or_fetch (&v, 2, __ATOMIC_CONSUME) !=  3)
 313     abort ();
 314
 315   count *= 2;
 316   if (__atomic_or_fetch (&v, count, __ATOMIC_ACQUIRE) !=  7)
 317     abort ();
 318
 319   count *= 2;
 320   if (__atomic_or_fetch (&v, 8, __ATOMIC_RELEASE) !=  15)
 321     abort ();
 322
 323   count *= 2;
 324   if (__atomic_or_fetch (&v, count, __ATOMIC_ACQ_REL) !=  31)
 325     abort ();
 326
 327   count *= 2;
 328   if (__atomic_or_fetch (&v, count, __ATOMIC_SEQ_CST) !=  63)
 329     abort ();
 330 }
 331
 332
 333 /* Test the OP routines with a result which isn't used. Use both variations
 334    within each function.  */
 335
 336 void
 337 test_add ()
 338 {
 339   v = 0;
 340   count = 1;
 341
 342   __atomic_add_fetch (&v, count, __ATOMIC_RELAXED);
 343   if (v != 1)
 344     abort ();
 345
 346   __atomic_fetch_add (&v, count, __ATOMIC_CONSUME);
 347   if (v != 2)
 348     abort ();
 349
 350   __atomic_add_fetch (&v, 1 , __ATOMIC_ACQUIRE);
 351   if (v != 3)
 352     abort ();
 353
 354   __atomic_fetch_add (&v, 1, __ATOMIC_RELEASE);
 355   if (v != 4)
 356     abort ();
 357
 358   __atomic_add_fetch (&v, count, __ATOMIC_ACQ_REL);
 359   if (v != 5)
 360     abort ();
 361
 362   __atomic_fetch_add (&v, count, __ATOMIC_SEQ_CST);
 363   if (v != 6)
 364     abort ();
 365 }
 366
 367
 368 void
 369 test_sub()
 370 {
 371   v = res = 20;
 372   count = 0;
 373
 374   __atomic_sub_fetch (&v, count + 1, __ATOMIC_RELAXED);
 375   if (v != --res)
 376     abort ();
 377
 378   __atomic_fetch_sub (&v, count + 1, __ATOMIC_CONSUME);
 379   if (v != --res)
 380     abort ();
 381
 382   __atomic_sub_fetch (&v, 1, __ATOMIC_ACQUIRE);
 383   if (v != --res)
 384     abort ();
 385
 386   __atomic_fetch_sub (&v, 1, __ATOMIC_RELEASE);
 387   if (v != --res)
 388     abort ();
 389
 390   __atomic_sub_fetch (&v, count + 1, __ATOMIC_ACQ_REL);
 391   if (v != --res)
 392     abort ();
 393
 394   __atomic_fetch_sub (&v, count + 1, __ATOMIC_SEQ_CST);
 395   if (v != --res)
 396     abort ();
 397 }
 398
 399 void
 400 test_and ()
 401 {
 402   v = init;
 403
 404   __atomic_and_fetch (&v, 0, __ATOMIC_RELAXED);
 405   if (v != 0)
 406     abort ();
 407
 408   v = init;
 409   __atomic_fetch_and (&v, init, __ATOMIC_CONSUME);
 410   if (v != init)
 411     abort ();
 412
 413   __atomic_and_fetch (&v, 0, __ATOMIC_ACQUIRE);
 414   if (v != 0)
 415     abort ();
 416
 417   v = ~v;
 418   __atomic_fetch_and (&v, init, __ATOMIC_RELEASE);
 419   if (v != init)
 420     abort ();
 421
 422   __atomic_and_fetch (&v, 0, __ATOMIC_ACQ_REL);
 423   if (v != 0)
 424     abort ();
 425
 426   v = ~v;
 427   __atomic_fetch_and (&v, 0, __ATOMIC_SEQ_CST);
 428   if (v != 0)
 429     abort ();
 430 }
 431
 432 void
 433 test_nand ()
 434 {
 435   v = init;
 436
 437   __atomic_fetch_nand (&v, 0, __ATOMIC_RELAXED);
 438   if (v != init)
 439     abort ();
 440
 441   __atomic_fetch_nand (&v, init, __ATOMIC_CONSUME);
 442   if (v != 0)
 443     abort ();
 444
 445   __atomic_nand_fetch (&v, 0, __ATOMIC_ACQUIRE);
 446   if (v != init)
 447     abort ();
 448
 449   __atomic_nand_fetch (&v, init, __ATOMIC_RELEASE);
 450   if (v != 0)
 451     abort ();
 452
 453   __atomic_fetch_nand (&v, init, __ATOMIC_ACQ_REL);
 454   if (v != init)
 455     abort ();
 456
 457   __atomic_nand_fetch (&v, 0, __ATOMIC_SEQ_CST);
 458   if (v != init)
 459     abort ();
 460 }
 461
 462
 463
 464 void
 465 test_xor ()
 466 {
 467   v = init;
 468   count = 0;
 469
 470   __atomic_xor_fetch (&v, count, __ATOMIC_RELAXED);
 471   if (v != init)
 472     abort ();
 473
 474   __atomic_fetch_xor (&v, ~count, __ATOMIC_CONSUME);
 475   if (v != 0)
 476     abort ();
 477
 478   __atomic_xor_fetch (&v, 0, __ATOMIC_ACQUIRE);
 479   if (v != 0)
 480     abort ();
 481
 482   __atomic_fetch_xor (&v, ~count, __ATOMIC_RELEASE);
 483   if (v != init)
 484     abort ();
 485
 486   __atomic_fetch_xor (&v, 0, __ATOMIC_ACQ_REL);
 487   if (v != init)
 488     abort ();
 489
 490   __atomic_xor_fetch (&v, ~count, __ATOMIC_SEQ_CST);
 491   if (v != 0)
 492     abort ();
 493 }
 494
 495 void
 496 test_or ()
 497 {
 498   v = 0;
 499   count = 1;
 500
 501   __atomic_or_fetch (&v, count, __ATOMIC_RELAXED);
 502   if (v != 1)
 503     abort ();
 504
 505   count *= 2;
 506   __atomic_fetch_or (&v, count, __ATOMIC_CONSUME);
 507   if (v != 3)
 508     abort ();
 509
 510   count *= 2;
 511   __atomic_or_fetch (&v, 4, __ATOMIC_ACQUIRE);
 512   if (v != 7)
 513     abort ();
 514
 515   count *= 2;
 516   __atomic_fetch_or (&v, 8, __ATOMIC_RELEASE);
 517   if (v != 15)
 518     abort ();
 519
 520   count *= 2;
 521   __atomic_or_fetch (&v, count, __ATOMIC_ACQ_REL);
 522   if (v != 31)
 523     abort ();
 524
 525   count *= 2;
 526   __atomic_fetch_or (&v, count, __ATOMIC_SEQ_CST);
 527   if (v != 63)
 528     abort ();
 529 }
 530
 531 main ()
 532 {
 533   test_fetch_add ();
 534   test_fetch_sub ();
 535   test_fetch_and ();
 536   test_fetch_nand ();
 537   test_fetch_xor ();
 538   test_fetch_or ();
 539
 540   test_add_fetch ();
 541   test_sub_fetch ();
 542   test_and_fetch ();
 543   test_nand_fetch ();
 544   test_xor_fetch ();
 545   test_or_fetch ();
 546
 547   test_add ();
 548   test_sub ();
 549   test_and ();
 550   test_nand ();
 551   test_xor ();
 552   test_or ();
 553
 554   return 0;
 555 }