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