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

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