libgomp/testsuite/libgomp.oacc-c-c++-common/atomic_capture-2.c

   1 /* { dg-do run } */
   2
   3 #include <stdlib.h>
   4
   5 int
   6 main(int argc, char **argv)
   7 {
   8   int   iexp, igot, imax, imin;
   9   long long lexp, lgot;
  10   int   N = 32;
  11   int   i;
  12   int   idata[N];
  13   long long ldata[N];
  14   float fexp, fgot;
  15   float fdata[N];
  16
  17   igot = 1234;
  18   iexp = 31;
  19
  20   for (i = 0; i < N; i++)
  21     idata[i] = i;
  22
  23 #pragma acc data copy (igot, idata[0:N])
  24   {
  25 #pragma acc parallel loop
  26     for (i = 0; i < N; i++)
  27 #pragma acc atomic capture
  28       { idata[i] = igot; igot = i; }
  29   }
  30
  31   imax = 0;
  32   imin = N;
  33
  34   for (i = 0; i < N; i++)
  35     {
  36       imax = idata[i] > imax ? idata[i] : imax;
  37       imin = idata[i] < imin ? idata[i] : imin;
  38     }
  39
  40   if (imax != 1234 || imin != 0)
  41     abort ();
  42
  43   return 0;
  44
  45   igot = 0;
  46   iexp = 32;
  47
  48 #pragma acc data copy (igot, idata[0:N])
  49   {
  50 #pragma acc parallel loop
  51     for (i = 0; i < N; i++)
  52 #pragma acc atomic capture
  53       { idata[i] = igot; igot++; }
  54   }
  55
  56   if (iexp != igot)
  57     abort ();
  58
  59   igot = 0;
  60   iexp = 32;
  61
  62 #pragma acc data copy (igot, idata[0:N])
  63   {
  64 #pragma acc parallel loop
  65     for (i = 0; i < N; i++)
  66 #pragma acc atomic capture
  67       { idata[i] = igot; ++igot; }
  68   }
  69
  70   if (iexp != igot)
  71     abort ();
  72
  73   igot = 0;
  74   iexp = 32;
  75
  76 #pragma acc data copy (igot, idata[0:N])
  77   {
  78 #pragma acc parallel loop
  79     for (i = 0; i < N; i++)
  80 #pragma acc atomic capture
  81       { ++igot; idata[i] = igot; }
  82   }
  83
  84   if (iexp != igot)
  85     abort ();
  86
  87   igot = 0;
  88   iexp = 32;
  89
  90 #pragma acc data copy (igot, idata[0:N])
  91   {
  92 #pragma acc parallel loop
  93     for (i = 0; i < N; i++)
  94 #pragma acc atomic capture
  95       { igot++; idata[i] = igot; }
  96   }
  97
  98   if (iexp != igot)
  99     abort ();
 100
 101   igot = 32;
 102   iexp = 0;
 103
 104 #pragma acc data copy (igot, idata[0:N])
 105   {
 106 #pragma acc parallel loop
 107     for (i = 0; i < N; i++)
 108 #pragma acc atomic capture
 109       { idata[i] = igot; igot--; }
 110   }
 111
 112   if (iexp != igot)
 113     abort ();
 114
 115   igot = 32;
 116   iexp = 0;
 117
 118 #pragma acc data copy (igot, idata[0:N])
 119   {
 120 #pragma acc parallel loop
 121     for (i = 0; i < N; i++)
 122 #pragma acc atomic capture
 123       { idata[i] = igot; --igot; }
 124   }
 125
 126   if (iexp != igot)
 127     abort ();
 128
 129   igot = 32;
 130   iexp = 0;
 131
 132 #pragma acc data copy (igot, idata[0:N])
 133   {
 134 #pragma acc parallel loop
 135     for (i = 0; i < N; i++)
 136 #pragma acc atomic capture
 137       { --igot; idata[i] = igot; }
 138   }
 139
 140   if (iexp != igot)
 141     abort ();
 142
 143   igot = 32;
 144   iexp = 0;
 145
 146 #pragma acc data copy (igot, idata[0:N])
 147   {
 148 #pragma acc parallel loop
 149     for (i = 0; i < N; i++)
 150 #pragma acc atomic capture
 151       { igot--; idata[i] = igot; }
 152   }
 153
 154   if (iexp != igot)
 155     abort ();
 156
 157   /* BINOP = + */
 158   igot = 0;
 159   iexp = 32;
 160
 161 #pragma acc data copy (igot, idata[0:N])
 162   {
 163 #pragma acc parallel loop
 164     for (i = 0; i < N; i++)
 165       {
 166         int expr = 1;
 167
 168 #pragma acc atomic capture
 169         { idata[i] = igot; igot += expr; }
 170       }
 171   }
 172
 173   if (iexp != igot)
 174     abort ();
 175
 176   igot = 0;
 177   iexp = 32;
 178
 179 #pragma acc data copy (igot, idata[0:N])
 180   {
 181 #pragma acc parallel loop
 182     for (i = 0; i < N; i++)
 183       {
 184         int expr = 1;
 185
 186 #pragma acc atomic capture
 187         { igot += expr; idata[i] = igot; }
 188       }
 189   }
 190
 191   if (iexp != igot)
 192     abort ();
 193
 194   igot = 0;
 195   iexp = 32;
 196
 197 #pragma acc data copy (igot, idata[0:N])
 198   {
 199 #pragma acc parallel loop
 200     for (i = 0; i < N; i++)
 201       {
 202         int expr = 1;
 203
 204 #pragma acc atomic capture
 205         { idata[i] = igot; igot = igot + expr; }
 206       }
 207   }
 208
 209   if (iexp != igot)
 210     abort ();
 211
 212   igot = 0;
 213   iexp = 32;
 214
 215 #pragma acc data copy (igot, idata[0:N])
 216   {
 217 #pragma acc parallel loop
 218     for (i = 0; i < N; i++)
 219       {
 220         int expr = 1;
 221
 222 #pragma acc atomic capture
 223         { idata[i] = igot; igot = expr + igot; }
 224       }
 225   }
 226
 227   if (iexp != igot)
 228     abort ();
 229
 230   igot = 0;
 231   iexp = 32;
 232
 233 #pragma acc data copy (igot, idata[0:N])
 234   {
 235 #pragma acc parallel loop
 236     for (i = 0; i < N; i++)
 237       {
 238         int expr = 1;
 239
 240 #pragma acc atomic capture
 241         { igot = igot + expr; idata[i] = igot; }
 242       }
 243   }
 244
 245   if (iexp != igot)
 246     abort ();
 247
 248
 249   igot = 0;
 250   iexp = 32;
 251
 252 #pragma acc data copy (igot, idata[0:N])
 253   {
 254 #pragma acc parallel loop
 255     for (i = 0; i < N; i++)
 256       {
 257         int expr = 1;
 258
 259 #pragma acc atomic capture
 260         { igot = expr + igot; idata[i] = igot; }
 261       }
 262   }
 263
 264   if (iexp != igot)
 265     abort ();
 266
 267   /* BINOP = * */
 268   lgot = 1LL;
 269   lexp = 1LL << 32;
 270
 271 #pragma acc data copy (lgot, ldata[0:N])
 272   {
 273 #pragma acc parallel loop
 274     for (i = 0; i < N; i++)
 275       {
 276       long long expr = 2LL;
 277
 278 #pragma acc atomic capture
 279       { ldata[i] = lgot; lgot *= expr; }
 280     }
 281   }
 282
 283   if (lexp != lgot)
 284     abort ();
 285
 286   lgot = 1LL;
 287   lexp = 1LL << 32;
 288
 289 #pragma acc data copy (lgot, ldata[0:N])
 290   {
 291 #pragma acc parallel loop
 292     for (i = 0; i < N; i++)
 293       {
 294         long long expr = 2LL;
 295
 296 #pragma acc atomic capture
 297         { lgot *= expr; ldata[i] = lgot; }
 298       }
 299   }
 300
 301   if (lexp != lgot)
 302     abort ();
 303
 304   lgot = 1LL;
 305   lexp = 1LL << 32;
 306
 307 #pragma acc data copy (lgot, ldata[0:N])
 308   {
 309 #pragma acc parallel loop
 310     for (i = 0; i < N; i++)
 311       {
 312         long long expr = 2LL;
 313
 314 #pragma acc atomic capture
 315         { ldata[i] = lgot; lgot = lgot * expr; }
 316       }
 317   }
 318
 319   if (lexp != lgot)
 320     abort ();
 321
 322   lgot = 1LL;
 323   lexp = 1LL << 32;
 324
 325 #pragma acc data copy (lgot, ldata[0:N])
 326   {
 327 #pragma acc parallel loop
 328     for (i = 0; i < N; i++)
 329       {
 330       long long expr = 2LL;
 331
 332 #pragma acc atomic capture
 333       { ldata[i] = lgot; lgot = expr * lgot; }
 334     }
 335   }
 336
 337   if (lexp != lgot)
 338     abort ();
 339
 340   lgot = 1LL;
 341   lexp = 1LL << 32;
 342
 343 #pragma acc data copy (lgot, ldata[0:N])
 344   {
 345 #pragma acc parallel loop
 346     for (i = 0; i < N; i++)
 347       {
 348         long long expr = 2LL;
 349
 350 #pragma acc atomic capture
 351         { lgot = lgot * expr; ldata[i] = lgot; }
 352       }
 353   }
 354
 355   if (lexp != lgot)
 356     abort ();
 357
 358   lgot = 1LL;
 359   lexp = 1LL << 32;
 360
 361 #pragma acc data copy (lgot, ldata[0:N])
 362   {
 363 #pragma acc parallel loop
 364     for (i = 0; i < N; i++)
 365       {
 366       long long expr = 2;
 367
 368 #pragma acc atomic capture
 369       { lgot = expr * lgot; ldata[i] = lgot; }
 370     }
 371   }
 372
 373   if (lexp != lgot)
 374     abort ();
 375
 376   /* BINOP = - */
 377   igot = 32;
 378   iexp = 0;
 379
 380 #pragma acc data copy (igot, idata[0:N])
 381   {
 382 #pragma acc parallel loop
 383     for (i = 0; i < N; i++)
 384       {
 385       int expr = 1;
 386
 387 #pragma acc atomic capture
 388       { idata[i] = igot; igot -= expr; }
 389     }
 390   }
 391
 392   if (iexp != igot)
 393     abort ();
 394
 395   igot = 32;
 396   iexp = 0;
 397
 398 #pragma acc data copy (igot, idata[0:N])
 399   {
 400 #pragma acc parallel loop
 401     for (i = 0; i < N; i++)
 402       {
 403         int expr = 1;
 404
 405 #pragma acc atomic capture
 406         { igot -= expr; idata[i] = igot; }
 407       }
 408   }
 409
 410   if (iexp != igot)
 411     abort ();
 412
 413   igot = 32;
 414   iexp = 0;
 415
 416 #pragma acc data copy (igot, idata[0:N])
 417   {
 418 #pragma acc parallel loop
 419     for (i = 0; i < N; i++)
 420       {
 421         int expr = 1;
 422
 423 #pragma acc atomic capture
 424         { idata[i] = igot; igot = igot - expr; }
 425       }
 426   }
 427
 428   if (iexp != igot)
 429     abort ();
 430
 431   igot = 1;
 432   iexp = 1;
 433
 434 #pragma acc data copy (igot, idata[0:N])
 435   {
 436 #pragma acc parallel loop
 437     for (i = 0; i < N; i++)
 438       {
 439       int expr = 1;
 440
 441 #pragma acc atomic capture
 442       { idata[i] = igot; igot = expr - igot; }
 443     }
 444   }
 445
 446   for (i = 0; i < N; i++)
 447     if (i % 2 == 0)
 448       {
 449         if (idata[i] != 1)
 450           abort ();
 451       }
 452     else
 453       {
 454         if (idata[i] != 0)
 455           abort ();
 456       }
 457
 458   if (iexp != igot)
 459     abort ();
 460
 461   igot = 1;
 462   iexp = -31;
 463
 464 #pragma acc data copy (igot, idata[0:N])
 465   {
 466 #pragma acc parallel loop
 467     for (i = 0; i < N; i++)
 468       {
 469         int expr = 1;
 470
 471 #pragma acc atomic capture
 472         { igot = igot - expr; idata[i] = igot; }
 473       }
 474   }
 475
 476   if (iexp != igot)
 477     abort ();
 478
 479   igot = 1;
 480   iexp = 1;
 481
 482 #pragma acc data copy (igot, idata[0:N])
 483   {
 484 #pragma acc parallel loop
 485     for (i = 0; i < N; i++)
 486       {
 487         int expr = 1;
 488
 489 #pragma acc atomic capture
 490         { igot = expr - igot; idata[i] = igot; }
 491       }
 492   }
 493
 494   for (i = 0; i < N; i++)
 495     if (i % 2 == 0)
 496       {
 497         if (idata[i] != 0)
 498           abort ();
 499       }
 500     else
 501       {
 502         if (idata[i] != 1)
 503           abort ();
 504       }
 505
 506   if (iexp != igot)
 507     abort ();
 508
 509   /* BINOP = / */
 510   lgot = 1LL << 32;
 511   lexp = 1LL;
 512
 513 #pragma acc data copy (lgot, ldata[0:N])
 514   {
 515 #pragma acc parallel loop
 516     for (i = 0; i < N; i++)
 517       {
 518         long long expr = 2LL;
 519
 520 #pragma acc atomic capture
 521         { ldata[i] = lgot; lgot /= expr; }
 522       }
 523   }
 524
 525   if (lexp != lgot)
 526     abort ();
 527
 528   lgot = 1LL << 32;
 529   lexp = 1LL;
 530
 531 #pragma acc data copy (lgot, ldata[0:N])
 532   {
 533 #pragma acc parallel loop
 534     for (i = 0; i < N; i++)
 535       {
 536         long long expr = 2LL;
 537
 538 #pragma acc atomic capture
 539         { lgot /= expr; ldata[i] = lgot; }
 540       }
 541   }
 542
 543   if (lexp != lgot)
 544     abort ();
 545
 546   lgot = 1LL << 32;
 547   lexp = 1LL;
 548
 549 #pragma acc data copy (lgot, ldata[0:N])
 550   {
 551 #pragma acc parallel loop
 552     for (i = 0; i < N; i++)
 553       {
 554       long long expr = 2LL;
 555
 556 #pragma acc atomic capture
 557       { ldata[i] = lgot; lgot = lgot / expr; }
 558     }
 559   }
 560
 561   if (lexp != lgot)
 562     abort ();
 563
 564   lgot = 2LL;
 565   lexp = 2LL;
 566
 567 #pragma acc data copy (lgot, ldata[0:N])
 568   {
 569 #pragma acc parallel loop
 570     for (i = 0; i < N; i++)
 571       {
 572         long long expr = 1LL << N;
 573
 574 #pragma acc atomic capture
 575         { ldata[i] = lgot; lgot = expr / lgot; }
 576       }
 577   }
 578
 579   if (lexp != lgot)
 580     abort ();
 581
 582   lgot = 2LL;
 583   lexp = 2LL;
 584
 585 #pragma acc data copy (lgot, ldata[0:N])
 586   {
 587 #pragma acc parallel loop
 588     for (i = 0; i < N; i++)
 589       {
 590         long long expr = 1LL << N;
 591
 592 #pragma acc atomic capture
 593         { lgot = lgot / expr; ldata[i] = lgot; }
 594       }
 595   }
 596
 597   if (lexp != lgot)
 598     abort ();
 599
 600   lgot = 2LL;
 601   lexp = 2LL;
 602
 603 #pragma acc data copy (lgot, ldata[0:N])
 604   {
 605 #pragma acc parallel loop
 606     for (i = 0; i < N; i++)
 607       {
 608         long long expr = 1LL << N;
 609
 610 #pragma acc atomic capture
 611         { lgot = expr / lgot; ldata[i] = lgot; }
 612       }
 613   }
 614
 615   if (lexp != lgot)
 616     abort ();
 617
 618   /* BINOP = & */
 619   lgot = ~0LL;
 620   lexp = 0LL;
 621
 622 #pragma acc data copy (lgot, ldata[0:N])
 623   {
 624 #pragma acc parallel loop
 625     for (i = 0; i < N; i++)
 626       {
 627         long long expr = ~(1 << i);
 628
 629 #pragma acc atomic capture
 630         { ldata[i] = lgot; lgot &= expr; }
 631       }
 632   }
 633
 634   if (lexp != lgot)
 635     abort ();
 636
 637   lgot = ~0LL;
 638   iexp = 0LL;
 639
 640 #pragma acc data copy (lgot, ldata[0:N])
 641   {
 642 #pragma acc parallel loop
 643     for (i = 0; i < N; i++)
 644       {
 645         long long expr = ~(1 << i);
 646
 647 #pragma acc atomic capture
 648         { lgot &= expr; ldata[i] = lgot; }
 649       }
 650   }
 651
 652   if (lexp != lgot)
 653     abort ();
 654
 655   lgot = ~0LL;
 656   lexp = 0LL;
 657
 658 #pragma acc data copy (lgot, ldata[0:N])
 659   {
 660 #pragma acc parallel loop
 661     for (i = 0; i < N; i++)
 662       {
 663         long long expr = ~(1 << i);
 664
 665 #pragma acc atomic capture
 666         { ldata[i] = lgot; lgot = lgot & expr; }
 667       }
 668   }
 669
 670   if (lexp != lgot)
 671     abort ();
 672
 673   lgot = ~0LL;
 674   lexp = 0LL;
 675
 676 #pragma acc data copy (lgot, ldata[0:N])
 677   {
 678 #pragma acc parallel loop
 679     for (i = 0; i < N; i++)
 680       {
 681         long long expr = ~(1 << i);
 682
 683 #pragma acc atomic capture
 684         { ldata[i] = lgot; lgot = expr & lgot; }
 685       }
 686   }
 687
 688   if (lexp != lgot)
 689     abort ();
 690
 691   lgot = ~0LL;
 692   iexp = 0LL;
 693
 694 #pragma acc data copy (lgot, ldata[0:N])
 695   {
 696 #pragma acc parallel loop
 697     for (i = 0; i < N; i++)
 698       {
 699         long long expr = ~(1 << i);
 700
 701 #pragma acc atomic capture
 702         { lgot = lgot & expr; ldata[i] = lgot; }
 703       }
 704   }
 705
 706   if (lexp != lgot)
 707     abort ();
 708
 709   lgot = ~0LL;
 710   lexp = 0LL;
 711
 712 #pragma acc data copy (lgot, ldata[0:N])
 713   {
 714 #pragma acc parallel loop
 715     for (i = 0; i < N; i++)
 716       {
 717       long long expr = ~(1 << i);
 718
 719 #pragma acc atomic capture
 720       { lgot = expr & lgot; ldata[i] = lgot; }
 721     }
 722   }
 723
 724   if (lexp != lgot)
 725     abort ();
 726
 727   /* BINOP = ^ */
 728   lgot = ~0LL;
 729   lexp = 0LL;
 730
 731 #pragma acc data copy (lgot, ldata[0:N])
 732   {
 733 #pragma acc parallel loop
 734     for (i = 0; i < N; i++)
 735       {
 736       long long expr = 1 << i;
 737
 738 #pragma acc atomic capture
 739       { ldata[i] = lgot; lgot ^= expr; }
 740     }
 741   }
 742
 743   if (lexp != lgot)
 744     abort ();
 745
 746   lgot = ~0LL;
 747   iexp = 0LL;
 748
 749 #pragma acc data copy (lgot, ldata[0:N])
 750   {
 751 #pragma acc parallel loop
 752     for (i = 0; i < N; i++)
 753       {
 754         long long expr = ~(1 << i);
 755
 756 #pragma acc atomic capture
 757         { lgot ^= expr; ldata[i] = lgot; }
 758       }
 759   }
 760
 761   if (lexp != lgot)
 762     abort ();
 763
 764   lgot = ~0LL;
 765   lexp = 0LL;
 766
 767 #pragma acc data copy (lgot, ldata[0:N])
 768   {
 769 #pragma acc parallel loop
 770     for (i = 0; i < N; i++)
 771       {
 772         long long expr = ~(1 << i);
 773
 774 #pragma acc atomic capture
 775         { ldata[i] = lgot; lgot = lgot ^ expr; }
 776       }
 777   }
 778
 779   if (lexp != lgot)
 780     abort ();
 781
 782   lgot = ~0LL;
 783   lexp = 0LL;
 784
 785 #pragma acc data copy (lgot, ldata[0:N])
 786   {
 787 #pragma acc parallel loop
 788     for (i = 0; i < N; i++)
 789       {
 790       long long expr = ~(1 << i);
 791
 792 #pragma acc atomic capture
 793       { ldata[i] = lgot; lgot = expr ^ lgot; }
 794     }
 795   }
 796
 797   if (lexp != lgot)
 798     abort ();
 799
 800   lgot = ~0LL;
 801   iexp = 0LL;
 802
 803 #pragma acc data copy (lgot, ldata[0:N])
 804   {
 805 #pragma acc parallel loop
 806     for (i = 0; i < N; i++)
 807       {
 808         long long expr = ~(1 << i);
 809
 810 #pragma acc atomic capture
 811         { lgot = lgot ^ expr; ldata[i] = lgot; }
 812       }
 813   }
 814
 815   if (lexp != lgot)
 816     abort ();
 817
 818   lgot = ~0LL;
 819   lexp = 0LL;
 820
 821 #pragma acc data copy (lgot, ldata[0:N])
 822   {
 823 #pragma acc parallel loop
 824     for (i = 0; i < N; i++)
 825       {
 826         long long expr = ~(1 << i);
 827
 828 #pragma acc atomic capture
 829         { lgot = expr ^ lgot; ldata[i] = lgot; }
 830       }
 831   }
 832
 833   if (lexp != lgot)
 834     abort ();
 835
 836   /* BINOP = | */
 837   lgot = 0LL;
 838   lexp = ~0LL;
 839
 840 #pragma acc data copy (lgot, ldata[0:N])
 841   {
 842 #pragma acc parallel loop
 843     for (i = 0; i < N; i++)
 844       {
 845         long long expr = 1 << i;
 846
 847 #pragma acc atomic capture
 848         { ldata[i] = lgot; lgot |= expr; }
 849       }
 850   }
 851
 852   if (lexp != lgot)
 853     abort ();
 854
 855   lgot = 0LL;
 856   iexp = ~0LL;
 857
 858 #pragma acc data copy (lgot, ldata[0:N])
 859   {
 860 #pragma acc parallel loop
 861     for (i = 0; i < N; i++)
 862       {
 863         long long expr = ~(1 << i);
 864
 865 #pragma acc atomic capture
 866         { lgot |= expr; ldata[i] = lgot; }
 867       }
 868   }
 869
 870   if (lexp != lgot)
 871     abort ();
 872
 873   lgot = 0LL;
 874   lexp = ~0LL;
 875
 876 #pragma acc data copy (lgot, ldata[0:N])
 877   {
 878 #pragma acc parallel loop
 879     for (i = 0; i < N; i++)
 880       {
 881         long long expr = ~(1 << i);
 882
 883 #pragma acc atomic capture
 884         { ldata[i] = lgot; lgot = lgot | expr; }
 885       }
 886   }
 887
 888   if (lexp != lgot)
 889     abort ();
 890
 891   lgot = 0LL;
 892   lexp = ~0LL;
 893
 894 #pragma acc data copy (lgot, ldata[0:N])
 895   {
 896 #pragma acc parallel loop
 897     for (i = 0; i < N; i++)
 898       {
 899         long long expr = ~(1 << i);
 900
 901 #pragma acc atomic capture
 902         { ldata[i] = lgot; lgot = expr | lgot; }
 903       }
 904   }
 905
 906   if (lexp != lgot)
 907     abort ();
 908
 909   lgot = 0LL;
 910   iexp = ~0LL;
 911
 912 #pragma acc data copy (lgot, ldata[0:N])
 913   {
 914 #pragma acc parallel loop
 915     for (i = 0; i < N; i++)
 916       {
 917         long long expr = ~(1 << i);
 918
 919 #pragma acc atomic capture
 920         { lgot = lgot | expr; ldata[i] = lgot; }
 921       }
 922   }
 923
 924   if (lexp != lgot)
 925     abort ();
 926
 927   lgot = 0LL;
 928   lexp = ~0LL;
 929
 930 #pragma acc data copy (lgot, ldata[0:N])
 931   {
 932 #pragma acc parallel loop
 933     for (i = 0; i < N; i++)
 934       {
 935         long long expr = ~(1 << i);
 936
 937 #pragma acc atomic capture
 938         { lgot = expr | lgot; ldata[i] = lgot; }
 939       }
 940   }
 941
 942   if (lexp != lgot)
 943     abort ();
 944
 945   /* BINOP = << */
 946   lgot = 1LL;
 947   lexp = 1LL << N;
 948
 949 #pragma acc data copy (lgot, ldata[0:N])
 950   {
 951 #pragma acc parallel loop
 952     for (i = 0; i < N; i++)
 953       {
 954         long long expr = 1LL;
 955
 956 #pragma acc atomic capture
 957         { ldata[i] = lgot; lgot <<= expr; }
 958       }
 959   }
 960
 961   if (lexp != lgot)
 962     abort ();
 963
 964   lgot = 1LL;
 965   iexp = 1LL << N;
 966
 967 #pragma acc data copy (lgot, ldata[0:N])
 968   {
 969 #pragma acc parallel loop
 970     for (i = 0; i < N; i++)
 971       {
 972         long long expr = 1LL;
 973
 974 #pragma acc atomic capture
 975         { lgot <<= expr; ldata[i] = lgot; }
 976       }
 977   }
 978
 979   if (lexp != lgot)
 980     abort ();
 981
 982   lgot = 1LL;
 983   lexp = 1LL << N;
 984
 985 #pragma acc data copy (lgot, ldata[0:N])
 986   {
 987 #pragma acc parallel loop
 988     for (i = 0; i < N; i++)
 989       {
 990         long long expr = 1LL;
 991
 992 #pragma acc atomic capture
 993         { ldata[i] = lgot; lgot = lgot << expr; }
 994       }
 995   }
 996
 997   if (lexp != lgot)
 998     abort ();
 999
1000   lgot = 1LL;
1001   lexp = 2LL;
1002
1003 #pragma acc data copy (lgot, ldata[0:N])
1004   {
1005 #pragma acc parallel loop
1006     for (i = 0; i < 1; i++)
1007       {
1008         long long expr = 1LL;
1009
1010 #pragma acc atomic capture
1011         { ldata[i] = lgot; lgot = expr << lgot; }
1012       }
1013   }
1014
1015   if (lexp != lgot)
1016     abort ();
1017
1018   lgot = 1LL;
1019   lexp = 2LL;
1020
1021 #pragma acc data copy (lgot, ldata[0:N])
1022   {
1023 #pragma acc parallel loop
1024     for (i = 0; i < 1; i++)
1025       {
1026         long long expr = 1LL;
1027
1028 #pragma acc atomic capture
1029         { lgot = lgot << expr; ldata[i] = lgot; }
1030       }
1031   }
1032
1033   if (lexp != lgot)
1034     abort ();
1035
1036   lgot = 1LL;
1037   lexp = 2LL;
1038
1039 #pragma acc data copy (lgot, ldata[0:N])
1040   {
1041 #pragma acc parallel loop
1042     for (i = 0; i < 1; i++)
1043       {
1044         long long expr = 1LL;
1045
1046 #pragma acc atomic capture
1047         { lgot = expr << lgot; ldata[i] = lgot; }
1048       }
1049   }
1050
1051   if (lexp != lgot)
1052     abort ();
1053
1054   /* BINOP = >> */
1055   lgot = 1LL << N;
1056   lexp = 1LL;
1057
1058 #pragma acc data copy (lgot, ldata[0:N])
1059   {
1060 #pragma acc parallel loop
1061     for (i = 0; i < N; i++)
1062       {
1063         long long expr = 1LL;
1064
1065 #pragma acc atomic capture
1066         { ldata[i] = lgot; lgot >>= expr; }
1067       }
1068   }
1069
1070   if (lexp != lgot)
1071     abort ();
1072
1073   lgot = 1LL << N;
1074   iexp = 1LL;
1075
1076 #pragma acc data copy (lgot, ldata[0:N])
1077   {
1078 #pragma acc parallel loop
1079     for (i = 0; i < N; i++)
1080       {
1081         long long expr = 1LL;
1082
1083 #pragma acc atomic capture
1084         { lgot >>= expr; ldata[i] = lgot; }
1085       }
1086   }
1087
1088   if (lexp != lgot)
1089     abort ();
1090
1091   lgot = 1LL << N;
1092   lexp = 1LL;
1093
1094 #pragma acc data copy (lgot, ldata[0:N])
1095   {
1096 #pragma acc parallel loop
1097     for (i = 0; i < N; i++)
1098       {
1099         long long expr = 1LL;
1100
1101 #pragma acc atomic capture
1102         { ldata[i] = lgot; lgot = lgot >> expr; }
1103       }
1104   }
1105
1106   if (lexp != lgot)
1107     abort ();
1108
1109   lgot = 1LL;
1110   lexp = 1LL << (N - 1);
1111
1112 #pragma acc data copy (lgot, ldata[0:N])
1113   {
1114 #pragma acc parallel loop
1115     for (i = 0; i < 1; i++)
1116       {
1117         long long expr = 1LL << N;
1118
1119 #pragma acc atomic capture
1120         { ldata[i] = lgot; lgot = expr >> lgot; }
1121     }
1122   }
1123
1124   if (lexp != lgot)
1125     abort ();
1126
1127   lgot = 1LL << N;
1128   lexp = 1LL;
1129
1130 #pragma acc data copy (lgot, ldata[0:N])
1131   {
1132 #pragma acc parallel loop
1133     for (i = 0; i < N; i++)
1134       {
1135         long long expr = 1LL;
1136
1137 #pragma acc atomic capture
1138         { lgot = lgot >> expr; ldata[i] = lgot; }
1139       }
1140   }
1141
1142   if (lexp != lgot)
1143     abort ();
1144
1145   lgot = 1LL;
1146   lexp = 1LL << (N - 1);
1147
1148 #pragma acc data copy (lgot, ldata[0:N])
1149   {
1150 #pragma acc parallel loop
1151     for (i = 0; i < 1; i++)
1152       {
1153         long long expr = 1LL << N;
1154
1155 #pragma acc atomic capture
1156         { lgot = expr >> lgot; ldata[i] = lgot; }
1157       }
1158   }
1159
1160   if (lexp != lgot)
1161     abort ();
1162
1163   // FLOAT FLOAT FLOAT
1164
1165   /* BINOP = + */
1166   fgot = 0.0;
1167   fexp = 32.0;
1168
1169 #pragma acc data copy (fgot, fdata[0:N])
1170   {
1171 #pragma acc parallel loop
1172     for (i = 0; i < N; i++)
1173       {
1174       float expr = 1.0;
1175
1176 #pragma acc atomic capture
1177       { fdata[i] = fgot; fgot += expr; }
1178     }
1179   }
1180
1181   if (fexp != fgot)
1182     abort ();
1183
1184   fgot = 0.0;
1185   fexp = 32.0;
1186
1187 #pragma acc data copy (fgot, fdata[0:N])
1188   {
1189 #pragma acc parallel loop
1190     for (i = 0; i < N; i++)
1191       {
1192         float expr = 1.0;
1193
1194 #pragma acc atomic capture
1195         { fgot += expr; fdata[i] = fgot; }
1196       }
1197   }
1198
1199   if (fexp != fgot)
1200     abort ();
1201
1202   fgot = 0.0;
1203   fexp = 32.0;
1204
1205 #pragma acc data copy (fgot, fdata[0:N])
1206   {
1207 #pragma acc parallel loop
1208     for (i = 0; i < N; i++)
1209       {
1210         float expr = 1.0;
1211
1212 #pragma acc atomic capture
1213         { idata[i] = fgot; fgot = fgot + expr; }
1214       }
1215   }
1216
1217   if (fexp != fgot)
1218     abort ();
1219
1220   fgot = 0.0;
1221   fexp = 32.0;
1222
1223 #pragma acc data copy (fgot, fdata[0:N])
1224   {
1225 #pragma acc parallel loop
1226     for (i = 0; i < N; i++)
1227       {
1228       float expr = 1.0;
1229
1230 #pragma acc atomic capture
1231       { fdata[i] = fgot; fgot = expr + fgot; }
1232     }
1233   }
1234
1235   if (fexp != fgot)
1236     abort ();
1237
1238   fgot = 0.0;
1239   fexp = 32.0;
1240
1241 #pragma acc data copy (fgot, fdata[0:N])
1242   {
1243 #pragma acc parallel loop
1244     for (i = 0; i < N; i++)
1245       {
1246         float expr = 1.0;
1247
1248 #pragma acc atomic capture
1249         { fgot = fgot + expr; fdata[i] = fgot; }
1250       }
1251   }
1252
1253   if (fexp != fgot)
1254     abort ();
1255
1256   fgot = 0.0;
1257   fexp = 32.0;
1258
1259 #pragma acc data copy (fgot, fdata[0:N])
1260   {
1261 #pragma acc parallel loop
1262     for (i = 0; i < N; i++)
1263       {
1264         float expr = 1.0;
1265
1266 #pragma acc atomic capture
1267         { fgot = expr + fgot; fdata[i] = fgot; }
1268       }
1269   }
1270
1271   if (fexp != fgot)
1272     abort ();
1273
1274   /* BINOP = * */
1275   fgot = 1.0;
1276   fexp = 8192.0*8192.0*64.0;
1277
1278 #pragma acc data copy (fgot, fdata[0:N])
1279   {
1280 #pragma acc parallel loop
1281     for (i = 0; i < N; i++)
1282       {
1283       float expr = 2.0;
1284
1285 #pragma acc atomic capture
1286       { fdata[i] = fgot; fgot *= expr; }
1287     }
1288   }
1289
1290   if (fexp != fgot)
1291     abort ();
1292
1293   fgot = 1.0;
1294   fexp = 8192.0*8192.0*64.0;
1295
1296 #pragma acc data copy (fgot, fdata[0:N])
1297   {
1298 #pragma acc parallel loop
1299     for (i = 0; i < N; i++)
1300       {
1301         float expr = 2.0;
1302
1303 #pragma acc atomic capture
1304         { fgot *= expr; fdata[i] = fgot; }
1305       }
1306   }
1307
1308   if (fexp != fgot)
1309     abort ();
1310
1311   fgot = 1.0;
1312   fexp = 8192.0*8192.0*64.0;
1313
1314 #pragma acc data copy (fgot, fdata[0:N])
1315   {
1316 #pragma acc parallel loop
1317     for (i = 0; i < N; i++)
1318       {
1319         float expr = 2.0;
1320
1321 #pragma acc atomic capture
1322         { fdata[i] = fgot; fgot = fgot * expr; }
1323       }
1324   }
1325
1326   if (fexp != fgot)
1327     abort ();
1328
1329   fgot = 1.0;
1330   fexp = 8192.0*8192.0*64.0;
1331
1332 #pragma acc data copy (fgot, fdata[0:N])
1333   {
1334 #pragma acc parallel loop
1335     for (i = 0; i < N; i++)
1336       {
1337         float expr = 2.0;
1338
1339 #pragma acc atomic capture
1340         { fdata[i] = fgot; fgot = expr * fgot; }
1341       }
1342   }
1343
1344   if (fexp != fgot)
1345     abort ();
1346
1347   lgot = 1LL;
1348   lexp = 1LL << 32;
1349
1350 #pragma acc data copy (lgot, ldata[0:N])
1351   {
1352 #pragma acc parallel loop
1353     for (i = 0; i < N; i++)
1354       {
1355       long long expr = 2LL;
1356
1357 #pragma acc atomic capture
1358       { lgot = lgot * expr; ldata[i] = lgot; }
1359     }
1360   }
1361
1362   if (lexp != lgot)
1363     abort ();
1364
1365   fgot = 1.0;
1366   fexp = 8192.0*8192.0*64.0;
1367
1368 #pragma acc data copy (fgot, fdata[0:N])
1369   {
1370 #pragma acc parallel loop
1371     for (i = 0; i < N; i++)
1372       {
1373         long long expr = 2;
1374
1375 #pragma acc atomic capture
1376         { fgot = expr * fgot; fdata[i] = fgot; }
1377       }
1378   }
1379
1380   if (fexp != fgot)
1381     abort ();
1382
1383   /* BINOP = - */
1384   fgot = 32.0;
1385   fexp = 0.0;
1386
1387 #pragma acc data copy (fgot, fdata[0:N])
1388   {
1389 #pragma acc parallel loop
1390     for (i = 0; i < N; i++)
1391       {
1392         float expr = 1.0;
1393
1394 #pragma acc atomic capture
1395         { fdata[i] = fgot; fgot -= expr; }
1396       }
1397   }
1398
1399   if (fexp != fgot)
1400     abort ();
1401
1402   fgot = 32.0;
1403   fexp = 0.0;
1404
1405 #pragma acc data copy (fgot, fdata[0:N])
1406   {
1407 #pragma acc parallel loop
1408     for (i = 0; i < N; i++)
1409       {
1410       float expr = 1.0;
1411
1412 #pragma acc atomic capture
1413       { fgot -= expr; fdata[i] = fgot; }
1414     }
1415   }
1416
1417   if (fexp != fgot)
1418     abort ();
1419
1420   fgot = 32.0;
1421   fexp = 0.0;
1422
1423 #pragma acc data copy (fgot, fdata[0:N])
1424   {
1425 #pragma acc parallel loop
1426     for (i = 0; i < N; i++)
1427       {
1428         float expr = 1.0;
1429
1430 #pragma acc atomic capture
1431         { fdata[i] = fgot; fgot = fgot - expr; }
1432       }
1433   }
1434
1435   if (fexp != fgot)
1436     abort ();
1437
1438   fgot = 1.0;
1439   fexp = 1.0;
1440
1441 #pragma acc data copy (fgot, fdata[0:N])
1442   {
1443 #pragma acc parallel loop
1444     for (i = 0; i < N; i++)
1445       {
1446         float expr = 1.0;
1447
1448 #pragma acc atomic capture
1449         { fdata[i] = fgot; fgot = expr - fgot; }
1450       }
1451   }
1452
1453   for (i = 0; i < N; i++)
1454     if (i % 2 == 0)
1455       {
1456         if (fdata[i] != 1.0)
1457           abort ();
1458       }
1459     else
1460       {
1461         if (fdata[i] != 0.0)
1462           abort ();
1463       }
1464
1465   if (fexp != fgot)
1466     abort ();
1467
1468   fgot = 1.0;
1469   fexp = -31.0;
1470
1471 #pragma acc data copy (fgot, fdata[0:N])
1472   {
1473 #pragma acc parallel loop
1474     for (i = 0; i < N; i++)
1475       {
1476         float expr = 1.0;
1477
1478 #pragma acc atomic capture
1479         { fgot = fgot - expr; fdata[i] = fgot; }
1480       }
1481   }
1482
1483   if (fexp != fgot)
1484     abort ();
1485
1486   fgot = 1.0;
1487   fexp = 1.0;
1488
1489 #pragma acc data copy (fgot, fdata[0:N])
1490   {
1491 #pragma acc parallel loop
1492     for (i = 0; i < N; i++)
1493       {
1494         float expr = 1.0;
1495
1496 #pragma acc atomic capture
1497         { fgot = expr - fgot; fdata[i] = fgot; }
1498       }
1499   }
1500
1501   for (i = 0; i < N; i++)
1502     if (i % 2 == 0)
1503       {
1504         if (fdata[i] != 0.0)
1505           abort ();
1506       }
1507     else
1508       {
1509         if (fdata[i] != 1.0)
1510           abort ();
1511       }
1512
1513   if (fexp != fgot)
1514     abort ();
1515
1516   /* BINOP = / */
1517   fgot = 8192.0*8192.0*64.0;
1518   fexp = 1.0;
1519
1520 #pragma acc data copy (fgot, fdata[0:N])
1521   {
1522 #pragma acc parallel loop
1523     for (i = 0; i < N; i++)
1524       {
1525         float expr = 2.0;
1526
1527 #pragma acc atomic capture
1528         { fdata[i] = fgot; fgot /= expr; }
1529       }
1530   }
1531
1532   if (fexp != fgot)
1533     abort ();
1534
1535   fgot = 8192.0*8192.0*64.0;
1536   fexp = 1.0;
1537
1538 #pragma acc data copy (fgot, fdata[0:N])
1539   {
1540 #pragma acc parallel loop
1541     for (i = 0; i < N; i++)
1542       {
1543         float expr = 2.0;
1544
1545 #pragma acc atomic capture
1546         { fgot /= expr; fdata[i] = fgot; }
1547       }
1548   }
1549
1550   if (fexp != fgot)
1551     abort ();
1552
1553   fgot = 8192.0*8192.0*64.0;
1554   fexp = 1.0;
1555
1556 #pragma acc data copy (fgot, fdata[0:N])
1557   {
1558 #pragma acc parallel loop
1559     for (i = 0; i < N; i++)
1560       {
1561         float expr = 2.0;
1562
1563 #pragma acc atomic capture
1564         { fdata[i] = fgot; fgot = fgot / expr; }
1565       }
1566   }
1567
1568   if (fexp != fgot)
1569     abort ();
1570
1571   fgot = 8192.0*8192.0*64.0;
1572   fexp = 1.0;
1573
1574 #pragma acc data copy (fgot, fdata[0:N])
1575   {
1576 #pragma acc parallel loop
1577     for (i = 0; i < N; i++)
1578       {
1579         float expr = 1.0;
1580
1581 #pragma acc atomic capture
1582         { fdata[i] = fgot; fgot = expr / fgot; }
1583       }
1584   }
1585
1586   if (fexp != fgot)
1587     abort ();
1588
1589   fgot = 4.0;
1590   fexp = 4.0;
1591
1592 #pragma acc data copy (fgot, fdata[0:N])
1593   {
1594 #pragma acc parallel loop
1595     for (i = 0; i < N; i++)
1596       {
1597         long long expr = 1LL << N;
1598
1599 #pragma acc atomic capture
1600         { fgot = fgot / expr; fdata[i] = fgot; }
1601       }
1602   }
1603
1604   if (fexp != fgot)
1605     abort ();
1606
1607   fgot = 4.0;
1608   fexp = 4.0;
1609
1610 #pragma acc data copy (fgot, fdata[0:N])
1611   {
1612 #pragma acc parallel loop
1613     for (i = 0; i < N; i++)
1614       {
1615         float expr = 2.0;
1616
1617 #pragma acc atomic capture
1618         { fgot = expr / fgot; fdata[i] = fgot; }
1619       }
1620   }
1621
1622   if (fexp != fgot)
1623     abort ();
1624
1625   return 0;
1626 }