Debian Codegraph @

libgomp/testsuite/libgomp.c++/baseptrs-4.C

raw
1 // { dg-do run }
2
3 #include <cstring>
4 #include <cassert>
5
6 #define MAP_DECLS
7
8 #define NONREF_DECL_BASE
9 #define REF_DECL_BASE
10 #define PTR_DECL_BASE
11 #define REF2PTR_DECL_BASE
12
13 #define ARRAY_DECL_BASE
14 #define REF2ARRAY_DECL_BASE
15 #define PTR_OFFSET_DECL_BASE
16 #define REF2PTR_OFFSET_DECL_BASE
17
18 #define MAP_SECTIONS
19
20 #define NONREF_DECL_MEMBER_SLICE
21 #define NONREF_DECL_MEMBER_SLICE_BASEPTR
22 #define REF_DECL_MEMBER_SLICE
23 #define REF_DECL_MEMBER_SLICE_BASEPTR
24 #define PTR_DECL_MEMBER_SLICE
25 #define PTR_DECL_MEMBER_SLICE_BASEPTR
26 #define REF2PTR_DECL_MEMBER_SLICE
27 #define REF2PTR_DECL_MEMBER_SLICE_BASEPTR
28
29 #define ARRAY_DECL_MEMBER_SLICE
30 #define ARRAY_DECL_MEMBER_SLICE_BASEPTR
31 #define REF2ARRAY_DECL_MEMBER_SLICE
32 #define REF2ARRAY_DECL_MEMBER_SLICE_BASEPTR
33 #define PTR_OFFSET_DECL_MEMBER_SLICE
34 #define PTR_OFFSET_DECL_MEMBER_SLICE_BASEPTR
35 #define REF2PTR_OFFSET_DECL_MEMBER_SLICE
36 #define REF2PTR_OFFSET_DECL_MEMBER_SLICE_BASEPTR
37
38 #define PTRARRAY_DECL_MEMBER_SLICE
39 #define PTRARRAY_DECL_MEMBER_SLICE_BASEPTR
40 #define REF2PTRARRAY_DECL_MEMBER_SLICE
41 #define REF2PTRARRAY_DECL_MEMBER_SLICE_BASEPTR
42 #define PTRPTR_OFFSET_DECL_MEMBER_SLICE
43 #define PTRPTR_OFFSET_DECL_MEMBER_SLICE_BASEPTR
44 #define REF2PTRPTR_OFFSET_DECL_MEMBER_SLICE
45 #define REF2PTRPTR_OFFSET_DECL_MEMBER_SLICE_BASEPTR
46
47 #define NONREF_COMPONENT_BASE
48 #define NONREF_COMPONENT_MEMBER_SLICE
49 #define NONREF_COMPONENT_MEMBER_SLICE_BASEPTR
50
51 #define REF_COMPONENT_BASE
52 #define REF_COMPONENT_MEMBER_SLICE
53 #define REF_COMPONENT_MEMBER_SLICE_BASEPTR
54
55 #define PTR_COMPONENT_BASE
56 #define PTR_COMPONENT_MEMBER_SLICE
57 #define PTR_COMPONENT_MEMBER_SLICE_BASEPTR
58
59 #define REF2PTR_COMPONENT_BASE
60 #define REF2PTR_COMPONENT_MEMBER_SLICE
61 #define REF2PTR_COMPONENT_MEMBER_SLICE_BASEPTR
62
63 #ifdef MAP_DECLS
64 void
65 map_decls (void)
66 {
67 int x = 0;
68 int &y = x;
69 int arr[4];
70 int (&arrref)[4] = arr;
71 int *z = &arr[0];
72 int *&t = z;
73
74 memset (arr, 0, sizeof arr);
75
76 #pragma omp target map(x)
77 {
78 x++;
79 }
80
81 #pragma omp target map(y)
82 {
83 y++;
84 }
85
86 assert (x == 2);
87 assert (y == 2);
88
89 /* "A variable that is of type pointer is treated as if it is the base
90 pointer of a zero-length array section that appeared as a list item in a
91 map clause." */
92 #pragma omp target map(z)
93 {
94 z++;
95 }
96
97 /* "A variable that is of type reference to pointer is treated as if it had
98 appeared in a map clause as a zero-length array section."
99
100 The pointer here is *not* associated with a target address, so we're not
101 disallowed from modifying it. */
102 #pragma omp target map(t)
103 {
104 t++;
105 }
106
107 assert (z == &arr[2]);
108 assert (t == &arr[2]);
109
110 #pragma omp target map(arr)
111 {
112 arr[2]++;
113 }
114
115 #pragma omp target map(arrref)
116 {
117 arrref[2]++;
118 }
119
120 assert (arr[2] == 2);
121 assert (arrref[2] == 2);
122 }
123 #endif
124
125 struct S {
126 int a;
127 int &b;
128 int *c;
129 int *&d;
130 int e[4];
131 int (&f)[4];
132
133 S(int a1, int &b1, int *c1, int *&d1) :
134 a(a1), b(b1), c(c1), d(d1), f(e)
135 {
136 memset (e, 0, sizeof e);
137 }
138 };
139
140 #ifdef NONREF_DECL_BASE
141 void
142 nonref_decl_base (void)
143 {
144 int a = 0, b = 0, c, *d = &c;
145 S mys(a, b, &c, d);
146
147 #pragma omp target map(mys.a)
148 {
149 mys.a++;
150 }
151
152 #pragma omp target map(mys.b)
153 {
154 mys.b++;
155 }
156
157 assert (mys.a == 1);
158 assert (mys.b == 1);
159
160 #pragma omp target map(mys.c)
161 {
162 mys.c++;
163 }
164
165 #pragma omp target map(mys.d)
166 {
167 mys.d++;
168 }
169
170 assert (mys.c == &c + 1);
171 assert (mys.d == &c + 1);
172
173 #pragma omp target map(mys.e)
174 {
175 mys.e[0]++;
176 }
177
178 #pragma omp target map(mys.f)
179 {
180 mys.f[0]++;
181 }
182
183 assert (mys.e[0] == 2);
184 assert (mys.f[0] == 2);
185 }
186 #endif
187
188 #ifdef REF_DECL_BASE
189 void
190 ref_decl_base (void)
191 {
192 int a = 0, b = 0, c, *d = &c;
193 S mys_orig(a, b, &c, d);
194 S &mys = mys_orig;
195
196 #pragma omp target map(mys.a)
197 {
198 mys.a++;
199 }
200
201 #pragma omp target map(mys.b)
202 {
203 mys.b++;
204 }
205
206 assert (mys.a == 1);
207 assert (mys.b == 1);
208
209 #pragma omp target map(mys.c)
210 {
211 mys.c++;
212 }
213
214 #pragma omp target map(mys.d)
215 {
216 mys.d++;
217 }
218
219 assert (mys.c == &c + 1);
220 assert (mys.d == &c + 1);
221
222 #pragma omp target map(mys.e)
223 {
224 mys.e[0]++;
225 }
226
227 #pragma omp target map(mys.f)
228 {
229 mys.f[0]++;
230 }
231
232 assert (mys.e[0] == 2);
233 assert (mys.f[0] == 2);
234 }
235 #endif
236
237 #ifdef PTR_DECL_BASE
238 void
239 ptr_decl_base (void)
240 {
241 int a = 0, b = 0, c, *d = &c;
242 S mys_orig(a, b, &c, d);
243 S *mys = &mys_orig;
244
245 #pragma omp target map(mys->a)
246 {
247 mys->a++;
248 }
249
250 #pragma omp target map(mys->b)
251 {
252 mys->b++;
253 }
254
255 assert (mys->a == 1);
256 assert (mys->b == 1);
257
258 #pragma omp target map(mys->c)
259 {
260 mys->c++;
261 }
262
263 #pragma omp target map(mys->d)
264 {
265 mys->d++;
266 }
267
268 assert (mys->c == &c + 1);
269 assert (mys->d == &c + 1);
270
271 #pragma omp target map(mys->e)
272 {
273 mys->e[0]++;
274 }
275
276 #pragma omp target map(mys->f)
277 {
278 mys->f[0]++;
279 }
280
281 assert (mys->e[0] == 2);
282 assert (mys->f[0] == 2);
283 }
284 #endif
285
286 #ifdef REF2PTR_DECL_BASE
287 void
288 ref2ptr_decl_base (void)
289 {
290 int a = 0, b = 0, c, *d = &c;
291 S mys_orig(a, b, &c, d);
292 S *mysp = &mys_orig;
293 S *&mys = mysp;
294
295 #pragma omp target map(mys->a)
296 {
297 mys->a++;
298 }
299
300 #pragma omp target map(mys->b)
301 {
302 mys->b++;
303 }
304
305 assert (mys->a == 1);
306 assert (mys->b == 1);
307
308 #pragma omp target map(mys->c)
309 {
310 mys->c++;
311 }
312
313 #pragma omp target map(mys->d)
314 {
315 mys->d++;
316 }
317
318 assert (mys->c == &c + 1);
319 assert (mys->d == &c + 1);
320
321 #pragma omp target map(mys->e)
322 {
323 mys->e[0]++;
324 }
325
326 #pragma omp target map(mys->f)
327 {
328 mys->f[0]++;
329 }
330
331 assert (mys->e[0] == 2);
332 assert (mys->f[0] == 2);
333 }
334 #endif
335
336 #ifdef ARRAY_DECL_BASE
337 void
338 array_decl_base (void)
339 {
340 int a = 0, b = 0, c, *d = &c;
341 S mys[4] =
342 {
343 S(a, b, &c, d),
344 S(a, b, &c, d),
345 S(a, b, &c, d),
346 S(a, b, &c, d)
347 };
348
349 #pragma omp target map(mys[2].a)
350 {
351 mys[2].a++;
352 }
353
354 #pragma omp target map(mys[2].b)
355 {
356 mys[2].b++;
357 }
358
359 assert (mys[2].a == 1);
360 assert (mys[2].b == 1);
361
362 #pragma omp target map(mys[2].c)
363 {
364 mys[2].c++;
365 }
366
367 #pragma omp target map(mys[2].d)
368 {
369 mys[2].d++;
370 }
371
372 assert (mys[2].c == &c + 1);
373 assert (mys[2].d == &c + 1);
374
375 #pragma omp target map(mys[2].e)
376 {
377 mys[2].e[0]++;
378 }
379
380 #pragma omp target map(mys[2].f)
381 {
382 mys[2].f[0]++;
383 }
384
385 assert (mys[2].e[0] == 2);
386 assert (mys[2].f[0] == 2);
387 }
388 #endif
389
390 #ifdef REF2ARRAY_DECL_BASE
391 void
392 ref2array_decl_base (void)
393 {
394 int a = 0, b = 0, c, *d = &c;
395 S mys_orig[4] =
396 {
397 S(a, b, &c, d),
398 S(a, b, &c, d),
399 S(a, b, &c, d),
400 S(a, b, &c, d)
401 };
402 S (&mys)[4] = mys_orig;
403
404 #pragma omp target map(mys[2].a)
405 {
406 mys[2].a++;
407 }
408
409 #pragma omp target map(mys[2].b)
410 {
411 mys[2].b++;
412 }
413
414 assert (mys[2].a == 1);
415 assert (mys[2].b == 1);
416
417 #pragma omp target map(mys[2].c)
418 {
419 mys[2].c++;
420 }
421
422 #pragma omp target map(mys[2].d)
423 {
424 mys[2].d++;
425 }
426
427 assert (mys[2].c == &c + 1);
428 assert (mys[2].d == &c + 1);
429
430 #pragma omp target map(mys[2].e)
431 {
432 mys[2].e[0]++;
433 }
434
435 #pragma omp target map(mys[2].f)
436 {
437 mys[2].f[0]++;
438 }
439
440 assert (mys[2].e[0] == 2);
441 assert (mys[2].f[0] == 2);
442 }
443 #endif
444
445 #ifdef PTR_OFFSET_DECL_BASE
446 void
447 ptr_offset_decl_base (void)
448 {
449 int a = 0, b = 0, c, *d = &c;
450 S mys_orig[4] =
451 {
452 S(a, b, &c, d),
453 S(a, b, &c, d),
454 S(a, b, &c, d),
455 S(a, b, &c, d)
456 };
457 S *mys = &mys_orig[0];
458
459 #pragma omp target map(mys[2].a)
460 {
461 mys[2].a++;
462 }
463
464 #pragma omp target map(mys[2].b)
465 {
466 mys[2].b++;
467 }
468
469 assert (mys[2].a == 1);
470 assert (mys[2].b == 1);
471
472 #pragma omp target map(mys[2].c)
473 {
474 mys[2].c++;
475 }
476
477 #pragma omp target map(mys[2].d)
478 {
479 mys[2].d++;
480 }
481
482 assert (mys[2].c == &c + 1);
483 assert (mys[2].d == &c + 1);
484
485 #pragma omp target map(mys[2].e)
486 {
487 mys[2].e[0]++;
488 }
489
490 #pragma omp target map(mys[2].f)
491 {
492 mys[2].f[0]++;
493 }
494
495 assert (mys[2].e[0] == 2);
496 assert (mys[2].f[0] == 2);
497 }
498 #endif
499
500 #ifdef REF2PTR_OFFSET_DECL_BASE
501 void
502 ref2ptr_offset_decl_base (void)
503 {
504 int a = 0, b = 0, c, *d = &c;
505 S mys_orig[4] =
506 {
507 S(a, b, &c, d),
508 S(a, b, &c, d),
509 S(a, b, &c, d),
510 S(a, b, &c, d)
511 };
512 S *mys_ptr = &mys_orig[0];
513 S *&mys = mys_ptr;
514
515 #pragma omp target map(mys[2].a)
516 {
517 mys[2].a++;
518 }
519
520 #pragma omp target map(mys[2].b)
521 {
522 mys[2].b++;
523 }
524
525 assert (mys[2].a == 1);
526 assert (mys[2].b == 1);
527
528 #pragma omp target map(mys[2].c)
529 {
530 mys[2].c++;
531 }
532
533 #pragma omp target map(mys[2].d)
534 {
535 mys[2].d++;
536 }
537
538 assert (mys[2].c == &c + 1);
539 assert (mys[2].d == &c + 1);
540
541 #pragma omp target map(mys[2].e)
542 {
543 mys[2].e[0]++;
544 }
545
546 #pragma omp target map(mys[2].f)
547 {
548 mys[2].f[0]++;
549 }
550
551 assert (mys[2].e[0] == 2);
552 assert (mys[2].f[0] == 2);
553 }
554 #endif
555
556 #ifdef MAP_SECTIONS
557 void
558 map_sections (void)
559 {
560 int arr[10];
561 int *ptr;
562 int (&arrref)[10] = arr;
563 int *&ptrref = ptr;
564
565 ptr = new int[10];
566 memset (ptr, 0, sizeof (int) * 10);
567 memset (arr, 0, sizeof (int) * 10);
568
569 #pragma omp target map(arr[0:10])
570 {
571 arr[2]++;
572 }
573
574 #pragma omp target map(ptr[0:10])
575 {
576 ptr[2]++;
577 }
578
579 #pragma omp target map(arrref[0:10])
580 {
581 arrref[2]++;
582 }
583
584 #pragma omp target map(ptrref[0:10])
585 {
586 ptrref[2]++;
587 }
588
589 assert (arr[2] == 2);
590 assert (ptr[2] == 2);
591
592 delete ptr;
593 }
594 #endif
595
596 struct T {
597 int a[10];
598 int (&b)[10];
599 int *c;
600 int *&d;
601
602 T(int (&b1)[10], int *c1, int *&d1) : b(b1), c(c1), d(d1)
603 {
604 memset (a, 0, sizeof a);
605 }
606 };
607
608 #ifdef NONREF_DECL_MEMBER_SLICE
609 void
610 nonref_decl_member_slice (void)
611 {
612 int c[10];
613 int *d = &c[0];
614 T myt(c, &c[0], d);
615
616 memset (c, 0, sizeof c);
617
618 #pragma omp target map(myt.a[0:10])
619 {
620 myt.a[2]++;
621 }
622
623 #pragma omp target map(myt.b[0:10])
624 {
625 myt.b[2]++;
626 }
627
628 #pragma omp target enter data map(to: myt.c)
629
630 #pragma omp target map(myt.c[0:10])
631 {
632 myt.c[2]++;
633 }
634
635 #pragma omp target exit data map(release: myt.c)
636
637 #pragma omp target enter data map(to: myt.d)
638
639 #pragma omp target map(myt.d[0:10])
640 {
641 myt.d[2]++;
642 }
643
644 #pragma omp target exit data map(from: myt.d)
645
646 assert (myt.a[2] == 1);
647 assert (myt.b[2] == 3);
648 assert (myt.c[2] == 3);
649 assert (myt.d[2] == 3);
650 }
651 #endif
652
653 #ifdef NONREF_DECL_MEMBER_SLICE_BASEPTR
654 void
655 nonref_decl_member_slice_baseptr (void)
656 {
657 int c[10];
658 int *d = &c[0];
659 T myt(c, &c[0], d);
660
661 memset (c, 0, sizeof c);
662
663 #pragma omp target map(to:myt.c) map(myt.c[0:10])
664 {
665 myt.c[2]++;
666 }
667
668 #pragma omp target map(to:myt.d) map(myt.d[0:10])
669 {
670 myt.d[2]++;
671 }
672
673 assert (myt.c[2] == 2);
674 assert (myt.d[2] == 2);
675 }
676 #endif
677
678 #ifdef REF_DECL_MEMBER_SLICE
679 void
680 ref_decl_member_slice (void)
681 {
682 int c[10];
683 int *d = &c[0];
684 T myt_real(c, &c[0], d);
685 T &myt = myt_real;
686
687 memset (c, 0, sizeof c);
688
689 #pragma omp target map(myt.a[0:10])
690 {
691 myt.a[2]++;
692 }
693
694 #pragma omp target map(myt.b[0:10])
695 {
696 myt.b[2]++;
697 }
698
699 #pragma omp target enter data map(to: myt.c)
700
701 #pragma omp target map(myt.c[0:10])
702 {
703 myt.c[2]++;
704 }
705
706 #pragma omp target exit data map(release: myt.c)
707
708 #pragma omp target enter data map(to: myt.d)
709
710 #pragma omp target map(myt.d[0:10])
711 {
712 myt.d[2]++;
713 }
714
715 #pragma omp target exit data map(release: myt.d)
716
717 assert (myt.a[2] == 1);
718 assert (myt.b[2] == 3);
719 assert (myt.c[2] == 3);
720 assert (myt.d[2] == 3);
721 }
722 #endif
723
724 #ifdef REF_DECL_MEMBER_SLICE_BASEPTR
725 void
726 ref_decl_member_slice_baseptr (void)
727 {
728 int c[10];
729 int *d = &c[0];
730 T myt_real(c, &c[0], d);
731 T &myt = myt_real;
732
733 memset (c, 0, sizeof c);
734
735 #pragma omp target map(to:myt.c) map(myt.c[0:10])
736 {
737 myt.c[2]++;
738 }
739
740 #pragma omp target map(to:myt.d) map(myt.d[0:10])
741 {
742 myt.d[2]++;
743 }
744
745 assert (myt.c[2] == 2);
746 assert (myt.d[2] == 2);
747 }
748 #endif
749
750 #ifdef PTR_DECL_MEMBER_SLICE
751 void
752 ptr_decl_member_slice (void)
753 {
754 int c[10];
755 int *d = &c[0];
756 T myt_real(c, &c[0], d);
757 T *myt = &myt_real;
758
759 memset (c, 0, sizeof c);
760
761 #pragma omp target enter data map(to: myt)
762
763 #pragma omp target map(myt->a[0:10])
764 {
765 myt->a[2]++;
766 }
767
768 #pragma omp target map(myt->b[0:10])
769 {
770 myt->b[2]++;
771 }
772
773 #pragma omp target enter data map(to: myt->c)
774
775 #pragma omp target map(myt->c[0:10])
776 {
777 myt->c[2]++;
778 }
779
780 #pragma omp target exit data map(release: myt->c)
781
782 #pragma omp target enter data map(to: myt->d)
783
784 #pragma omp target map(myt->d[0:10])
785 {
786 myt->d[2]++;
787 }
788
789 #pragma omp target exit data map(release: myt, myt->d)
790
791 assert (myt->a[2] == 1);
792 assert (myt->b[2] == 3);
793 assert (myt->c[2] == 3);
794 assert (myt->d[2] == 3);
795 }
796 #endif
797
798 #ifdef PTR_DECL_MEMBER_SLICE_BASEPTR
799 void
800 ptr_decl_member_slice_baseptr (void)
801 {
802 int c[10];
803 int *d = &c[0];
804 T myt_real(c, &c[0], d);
805 T *myt = &myt_real;
806
807 memset (c, 0, sizeof c);
808
809 // These ones have an implicit firstprivate for 'myt'.
810 #pragma omp target map(to:myt->c) map(myt->c[0:10])
811 {
812 myt->c[2]++;
813 }
814
815 #pragma omp target map(to:myt->d) map(myt->d[0:10])
816 {
817 myt->d[2]++;
818 }
819
820 // These ones have an explicit "TO" mapping for 'myt'.
821 #pragma omp target map(to:myt) map(to:myt->c) map(myt->c[0:10])
822 {
823 myt->c[2]++;
824 }
825
826 #pragma omp target map(to:myt) map(to:myt->d) map(myt->d[0:10])
827 {
828 myt->d[2]++;
829 }
830
831 assert (myt->c[2] == 4);
832 assert (myt->d[2] == 4);
833 }
834 #endif
835
836 #ifdef REF2PTR_DECL_MEMBER_SLICE
837 void
838 ref2ptr_decl_member_slice (void)
839 {
840 int c[10];
841 int *d = &c[0];
842 T myt_real(c, &c[0], d);
843 T *myt_ptr = &myt_real;
844 T *&myt = myt_ptr;
845
846 memset (c, 0, sizeof c);
847
848 #pragma omp target enter data map(to: myt)
849
850 #pragma omp target map(myt->a[0:10])
851 {
852 myt->a[2]++;
853 }
854
855 #pragma omp target map(myt->b[0:10])
856 {
857 myt->b[2]++;
858 }
859
860 #pragma omp target enter data map(to: myt->c)
861
862 #pragma omp target map(myt->c[0:10])
863 {
864 myt->c[2]++;
865 }
866
867 #pragma omp target exit data map(release: myt->c)
868
869 #pragma omp target enter data map(to: myt->d)
870
871 #pragma omp target map(myt->d[0:10])
872 {
873 myt->d[2]++;
874 }
875
876 #pragma omp target exit data map(from: myt, myt->d)
877
878 assert (myt->a[2] == 1);
879 assert (myt->b[2] == 3);
880 assert (myt->c[2] == 3);
881 assert (myt->d[2] == 3);
882 }
883 #endif
884
885 #ifdef REF2PTR_DECL_MEMBER_SLICE_BASEPTR
886 void
887 ref2ptr_decl_member_slice_baseptr (void)
888 {
889 int c[10];
890 int *d = &c[0];
891 T myt_real(c, &c[0], d);
892 T *myt_ptr = &myt_real;
893 T *&myt = myt_ptr;
894
895 memset (c, 0, sizeof c);
896
897 // These ones have an implicit firstprivate for 'myt'.
898 #pragma omp target map(to:myt->c) map(myt->c[0:10])
899 {
900 myt->c[2]++;
901 }
902
903 #pragma omp target map(to:myt->d) map(myt->d[0:10])
904 {
905 myt->d[2]++;
906 }
907
908 // These ones have an explicit "TO" mapping for 'myt'.
909 #pragma omp target map(to:myt) map(to:myt->c) map(myt->c[0:10])
910 {
911 myt->c[2]++;
912 }
913
914 #pragma omp target map(to:myt) map(to:myt->d) map(myt->d[0:10])
915 {
916 myt->d[2]++;
917 }
918
919 assert (myt->c[2] == 4);
920 assert (myt->d[2] == 4);
921 }
922 #endif
923
924 #ifdef ARRAY_DECL_MEMBER_SLICE
925 void
926 array_decl_member_slice (void)
927 {
928 int c[10];
929 int *d = &c[0];
930 T myt[4] =
931 {
932 T (c, &c[0], d),
933 T (c, &c[0], d),
934 T (c, &c[0], d),
935 T (c, &c[0], d)
936 };
937
938 memset (c, 0, sizeof c);
939
940 #pragma omp target map(myt[2].a[0:10])
941 {
942 myt[2].a[2]++;
943 }
944
945 #pragma omp target map(myt[2].b[0:10])
946 {
947 myt[2].b[2]++;
948 }
949
950 #pragma omp target enter data map(to: myt[2].c)
951
952 #pragma omp target map(myt[2].c[0:10])
953 {
954 myt[2].c[2]++;
955 }
956
957 #pragma omp target exit data map(release: myt[2].c)
958
959 #pragma omp target enter data map(to: myt[2].d)
960
961 #pragma omp target map(myt[2].d[0:10])
962 {
963 myt[2].d[2]++;
964 }
965
966 #pragma omp target exit data map(release: myt[2].d)
967
968 assert (myt[2].a[2] == 1);
969 assert (myt[2].b[2] == 3);
970 assert (myt[2].c[2] == 3);
971 assert (myt[2].d[2] == 3);
972 }
973 #endif
974
975 #ifdef ARRAY_DECL_MEMBER_SLICE_BASEPTR
976 void
977 array_decl_member_slice_baseptr (void)
978 {
979 int c[10];
980 int *d = &c[0];
981 T myt[4] =
982 {
983 T (c, &c[0], d),
984 T (c, &c[0], d),
985 T (c, &c[0], d),
986 T (c, &c[0], d)
987 };
988
989 memset (c, 0, sizeof c);
990
991 #pragma omp target map(to:myt[2].c) map(myt[2].c[0:10])
992 {
993 myt[2].c[2]++;
994 }
995
996 #pragma omp target map(to:myt[2].d) map(myt[2].d[0:10])
997 {
998 myt[2].d[2]++;
999 }
1000
1001 assert (myt[2].c[2] == 2);
1002 assert (myt[2].d[2] == 2);
1003 }
1004 #endif
1005
1006 #ifdef REF2ARRAY_DECL_MEMBER_SLICE
1007 void
1008 ref2array_decl_member_slice (void)
1009 {
1010 int c[10];
1011 int *d = &c[0];
1012 T myt_real[4] =
1013 {
1014 T (c, &c[0], d),
1015 T (c, &c[0], d),
1016 T (c, &c[0], d),
1017 T (c, &c[0], d)
1018 };
1019 T (&myt)[4] = myt_real;
1020
1021 memset (c, 0, sizeof c);
1022
1023 #pragma omp target map(myt[2].a[0:10])
1024 {
1025 myt[2].a[2]++;
1026 }
1027
1028 #pragma omp target map(myt[2].b[0:10])
1029 {
1030 myt[2].b[2]++;
1031 }
1032
1033 #pragma omp target enter data map(to: myt[2].c)
1034
1035 #pragma omp target map(myt[2].c[0:10])
1036 {
1037 myt[2].c[2]++;
1038 }
1039
1040 #pragma omp target exit data map(release: myt[2].c)
1041
1042 #pragma omp target enter data map(to: myt[2].d)
1043
1044 #pragma omp target map(myt[2].d[0:10])
1045 {
1046 myt[2].d[2]++;
1047 }
1048
1049 #pragma omp target exit data map(release: myt[2].d)
1050
1051 assert (myt[2].a[2] == 1);
1052 assert (myt[2].b[2] == 3);
1053 assert (myt[2].c[2] == 3);
1054 assert (myt[2].d[2] == 3);
1055 }
1056 #endif
1057
1058 #ifdef REF2ARRAY_DECL_MEMBER_SLICE_BASEPTR
1059 void
1060 ref2array_decl_member_slice_baseptr (void)
1061 {
1062 int c[10];
1063 int *d = &c[0];
1064 T myt_real[4] =
1065 {
1066 T (c, &c[0], d),
1067 T (c, &c[0], d),
1068 T (c, &c[0], d),
1069 T (c, &c[0], d)
1070 };
1071 T (&myt)[4] = myt_real;
1072
1073 memset (c, 0, sizeof c);
1074
1075 #pragma omp target map(to:myt[2].c) map(myt[2].c[0:10])
1076 {
1077 myt[2].c[2]++;
1078 }
1079
1080 #pragma omp target map(to:myt[2].d) map(myt[2].d[0:10])
1081 {
1082 myt[2].d[2]++;
1083 }
1084
1085 assert (myt[2].c[2] == 2);
1086 assert (myt[2].d[2] == 2);
1087 }
1088 #endif
1089
1090 #ifdef PTR_OFFSET_DECL_MEMBER_SLICE
1091 void
1092 ptr_offset_decl_member_slice (void)
1093 {
1094 int c[10];
1095 int *d = &c[0];
1096 T myt_real[4] =
1097 {
1098 T (c, &c[0], d),
1099 T (c, &c[0], d),
1100 T (c, &c[0], d),
1101 T (c, &c[0], d)
1102 };
1103 T *myt = &myt_real[0];
1104
1105 memset (c, 0, sizeof c);
1106
1107 #pragma omp target map(myt[2].a[0:10])
1108 {
1109 myt[2].a[2]++;
1110 }
1111
1112 #pragma omp target map(myt[2].b[0:10])
1113 {
1114 myt[2].b[2]++;
1115 }
1116
1117 #pragma omp target enter data map(to: myt[2].c)
1118
1119 #pragma omp target map(myt[2].c[0:10])
1120 {
1121 myt[2].c[2]++;
1122 }
1123
1124 #pragma omp target exit data map(release: myt[2].c)
1125
1126 #pragma omp target enter data map(to: myt[2].d)
1127
1128 #pragma omp target map(myt[2].d[0:10])
1129 {
1130 myt[2].d[2]++;
1131 }
1132
1133 #pragma omp target exit data map(release: myt[2].d)
1134
1135 assert (myt[2].a[2] == 1);
1136 assert (myt[2].b[2] == 3);
1137 assert (myt[2].c[2] == 3);
1138 assert (myt[2].d[2] == 3);
1139 }
1140 #endif
1141
1142 #ifdef PTR_OFFSET_DECL_MEMBER_SLICE_BASEPTR
1143 void
1144 ptr_offset_decl_member_slice_baseptr (void)
1145 {
1146 int c[10];
1147 int *d = &c[0];
1148 T myt_real[4] =
1149 {
1150 T (c, &c[0], d),
1151 T (c, &c[0], d),
1152 T (c, &c[0], d),
1153 T (c, &c[0], d)
1154 };
1155 T *myt = &myt_real[0];
1156
1157 memset (c, 0, sizeof c);
1158
1159 /* Implicit 'myt'. */
1160 #pragma omp target map(to:myt[2].c) map(myt[2].c[0:10])
1161 {
1162 myt[2].c[2]++;
1163 }
1164
1165 #pragma omp target map(to:myt[2].d) map(myt[2].d[0:10])
1166 {
1167 myt[2].d[2]++;
1168 }
1169
1170 /* Explicit 'to'-mapped 'myt'. */
1171 #pragma omp target map(to:myt) map(to:myt[2].c) map(myt[2].c[0:10])
1172 {
1173 myt[2].c[2]++;
1174 }
1175
1176 #pragma omp target map(to:myt) map(to:myt[2].d) map(myt[2].d[0:10])
1177 {
1178 myt[2].d[2]++;
1179 }
1180
1181 assert (myt[2].c[2] == 4);
1182 assert (myt[2].d[2] == 4);
1183 }
1184 #endif
1185
1186 #ifdef REF2PTR_OFFSET_DECL_MEMBER_SLICE
1187 void
1188 ref2ptr_offset_decl_member_slice (void)
1189 {
1190 int c[10];
1191 int *d = &c[0];
1192 T myt_real[4] =
1193 {
1194 T (c, &c[0], d),
1195 T (c, &c[0], d),
1196 T (c, &c[0], d),
1197 T (c, &c[0], d)
1198 };
1199 T *myt_ptr = &myt_real[0];
1200 T *&myt = myt_ptr;
1201
1202 memset (c, 0, sizeof c);
1203
1204 #pragma omp target map(myt[2].a[0:10])
1205 {
1206 myt[2].a[2]++;
1207 }
1208
1209 #pragma omp target map(myt[2].b[0:10])
1210 {
1211 myt[2].b[2]++;
1212 }
1213
1214 #pragma omp target enter data map(to: myt[2].c)
1215
1216 #pragma omp target map(myt[2].c[0:10])
1217 {
1218 myt[2].c[2]++;
1219 }
1220
1221 #pragma omp target exit data map(release: myt[2].c)
1222
1223 #pragma omp target enter data map(to: myt[2].d)
1224
1225 #pragma omp target map(myt[2].d[0:10])
1226 {
1227 myt[2].d[2]++;
1228 }
1229
1230 #pragma omp target exit data map(release: myt[2].d)
1231
1232 assert (myt[2].a[2] == 1);
1233 assert (myt[2].b[2] == 3);
1234 assert (myt[2].c[2] == 3);
1235 assert (myt[2].d[2] == 3);
1236 }
1237 #endif
1238
1239 #ifdef REF2PTR_OFFSET_DECL_MEMBER_SLICE_BASEPTR
1240 void
1241 ref2ptr_offset_decl_member_slice_baseptr (void)
1242 {
1243 int c[10];
1244 int *d = &c[0];
1245 T myt_real[4] =
1246 {
1247 T (c, &c[0], d),
1248 T (c, &c[0], d),
1249 T (c, &c[0], d),
1250 T (c, &c[0], d)
1251 };
1252 T *myt_ptr = &myt_real[0];
1253 T *&myt = myt_ptr;
1254
1255 memset (c, 0, sizeof c);
1256
1257 /* Implicit 'myt'. */
1258 #pragma omp target map(to:myt[2].c) map(myt[2].c[0:10])
1259 {
1260 myt[2].c[2]++;
1261 }
1262
1263 #pragma omp target map(to:myt[2].d) map(myt[2].d[0:10])
1264 {
1265 myt[2].d[2]++;
1266 }
1267
1268 /* Explicit 'to'-mapped 'myt'. */
1269 #pragma omp target map(to:myt) map(to:myt[2].c) map(myt[2].c[0:10])
1270 {
1271 myt[2].c[2]++;
1272 }
1273
1274 #pragma omp target map(to:myt) map(to:myt[2].d) map(myt[2].d[0:10])
1275 {
1276 myt[2].d[2]++;
1277 }
1278
1279 assert (myt[2].c[2] == 4);
1280 assert (myt[2].d[2] == 4);
1281 }
1282 #endif
1283
1284 #ifdef PTRARRAY_DECL_MEMBER_SLICE
1285 void
1286 ptrarray_decl_member_slice (void)
1287 {
1288 int c[10];
1289 int *d = &c[0];
1290 T myt_real(c, &c[0], d);
1291 T *myt[4] =
1292 {
1293 &myt_real,
1294 &myt_real,
1295 &myt_real,
1296 &myt_real
1297 };
1298
1299 memset (c, 0, sizeof c);
1300
1301 #pragma omp target enter data map(to: myt[2])
1302
1303 #pragma omp target map(myt[2]->a[0:10])
1304 {
1305 myt[2]->a[2]++;
1306 }
1307
1308 #pragma omp target map(myt[2]->b[0:10])
1309 {
1310 myt[2]->b[2]++;
1311 }
1312
1313 #pragma omp target enter data map(to: myt[2]->c)
1314
1315 #pragma omp target map(myt[2]->c[0:10])
1316 {
1317 myt[2]->c[2]++;
1318 }
1319
1320 #pragma omp target exit data map(from: myt[2]->c)
1321
1322 #pragma omp target enter data map(to: myt[2]->d)
1323
1324 #pragma omp target map(myt[2]->d[0:10])
1325 {
1326 myt[2]->d[2]++;
1327 }
1328
1329 #pragma omp target exit data map(from: myt[2]->d)
1330
1331 #pragma omp target exit data map(release: myt[2])
1332
1333 assert (myt[2]->a[2] == 1);
1334 assert (myt[2]->b[2] == 3);
1335 assert (myt[2]->c[2] == 3);
1336 assert (myt[2]->d[2] == 3);
1337 }
1338 #endif
1339
1340 #ifdef PTRARRAY_DECL_MEMBER_SLICE_BASEPTR
1341 void
1342 ptrarray_decl_member_slice_baseptr (void)
1343 {
1344 int c[10];
1345 int *d = &c[0];
1346 T myt_real(c, &c[0], d);
1347 T *myt[4] =
1348 {
1349 &myt_real,
1350 &myt_real,
1351 &myt_real,
1352 &myt_real
1353 };
1354
1355 memset (c, 0, sizeof c);
1356
1357 // Implicit 'myt'
1358 #pragma omp target map(to: myt[2]->c) map(myt[2]->c[0:10])
1359 {
1360 myt[2]->c[2]++;
1361 }
1362
1363 #pragma omp target map(to: myt[2]->d) map(myt[2]->d[0:10])
1364 {
1365 myt[2]->d[2]++;
1366 }
1367
1368 // One element of 'myt'
1369 #pragma omp target map(to:myt[2], myt[2]->c) map(myt[2]->c[0:10])
1370 {
1371 myt[2]->c[2]++;
1372 }
1373
1374 #pragma omp target map(to:myt[2], myt[2]->d) map(myt[2]->d[0:10])
1375 {
1376 myt[2]->d[2]++;
1377 }
1378
1379 // Explicit map of all of 'myt'
1380 #pragma omp target map(to:myt, myt[2]->c) map(myt[2]->c[0:10])
1381 {
1382 myt[2]->c[2]++;
1383 }
1384
1385 #pragma omp target map(to:myt, myt[2]->d) map(myt[2]->d[0:10])
1386 {
1387 myt[2]->d[2]++;
1388 }
1389
1390 // Explicit map slice of 'myt'
1391 #pragma omp target map(to:myt[1:3], myt[2]->c) map(myt[2]->c[0:10])
1392 {
1393 myt[2]->c[2]++;
1394 }
1395
1396 #pragma omp target map(to:myt[1:3], myt[2]->d) map(myt[2]->d[0:10])
1397 {
1398 myt[2]->d[2]++;
1399 }
1400
1401 assert (myt[2]->c[2] == 8);
1402 assert (myt[2]->d[2] == 8);
1403 }
1404 #endif
1405
1406 #ifdef REF2PTRARRAY_DECL_MEMBER_SLICE
1407 void
1408 ref2ptrarray_decl_member_slice (void)
1409 {
1410 int c[10];
1411 int *d = &c[0];
1412 T myt_real(c, &c[0], d);
1413 T *myt_ptrarr[4] =
1414 {
1415 &myt_real,
1416 &myt_real,
1417 &myt_real,
1418 &myt_real
1419 };
1420 T *(&myt)[4] = myt_ptrarr;
1421
1422 memset (c, 0, sizeof c);
1423
1424 #pragma omp target enter data map(to: myt[2])
1425
1426 #pragma omp target map(myt[2]->a[0:10])
1427 {
1428 myt[2]->a[2]++;
1429 }
1430
1431 #pragma omp target map(myt[2]->b[0:10])
1432 {
1433 myt[2]->b[2]++;
1434 }
1435
1436 #pragma omp target enter data map(to: myt[2]->c)
1437
1438 #pragma omp target map(myt[2]->c[0:10])
1439 {
1440 myt[2]->c[2]++;
1441 }
1442
1443 #pragma omp target exit data map(release: myt[2]->c)
1444
1445 #pragma omp target enter data map(to: myt[2]->d)
1446
1447 #pragma omp target map(myt[2]->d[0:10])
1448 {
1449 myt[2]->d[2]++;
1450 }
1451
1452 #pragma omp target exit data map(release: myt[2]->d)
1453
1454 #pragma omp target exit data map(release: myt[2])
1455
1456 assert (myt[2]->a[2] == 1);
1457 assert (myt[2]->b[2] == 3);
1458 assert (myt[2]->c[2] == 3);
1459 assert (myt[2]->d[2] == 3);
1460 }
1461 #endif
1462
1463 #ifdef REF2PTRARRAY_DECL_MEMBER_SLICE_BASEPTR
1464 void
1465 ref2ptrarray_decl_member_slice_baseptr (void)
1466 {
1467 int c[10];
1468 int *d = &c[0];
1469 T myt_real(c, &c[0], d);
1470 T *myt_ptrarr[4] =
1471 {
1472 &myt_real,
1473 &myt_real,
1474 &myt_real,
1475 &myt_real
1476 };
1477 T *(&myt)[4] = myt_ptrarr;
1478
1479 memset (c, 0, sizeof c);
1480
1481 #pragma omp target map(to:myt[2], myt[2]->c) map(myt[2]->c[0:10])
1482 {
1483 myt[2]->c[2]++;
1484 }
1485
1486 #pragma omp target map(to:myt[2], myt[2]->d) map(myt[2]->d[0:10])
1487 {
1488 myt[2]->d[2]++;
1489 }
1490
1491 #pragma omp target map(to:myt, myt[2]->c) map(myt[2]->c[0:10])
1492 {
1493 myt[2]->c[2]++;
1494 }
1495
1496 #pragma omp target map(to:myt, myt[2]->d) map(myt[2]->d[0:10])
1497 {
1498 myt[2]->d[2]++;
1499 }
1500
1501 assert (myt[2]->c[2] == 4);
1502 assert (myt[2]->d[2] == 4);
1503 }
1504 #endif
1505
1506 #ifdef PTRPTR_OFFSET_DECL_MEMBER_SLICE
1507 void
1508 ptrptr_offset_decl_member_slice (void)
1509 {
1510 int c[10];
1511 int *d = &c[0];
1512 T myt_real(c, &c[0], d);
1513 T *myt_ptrarr[4] =
1514 {
1515 &myt_real,
1516 &myt_real,
1517 &myt_real,
1518 &myt_real
1519 };
1520 T **myt = &myt_ptrarr[0];
1521
1522 memset (c, 0, sizeof c);
1523
1524 #pragma omp target enter data map(to: myt[0:3])
1525
1526 /* NOTE: For the implicit firstprivate 'myt' to work, the zeroth element of
1527 myt[] must be mapped above -- otherwise the zero-length array section
1528 lookup fails. */
1529 #pragma omp target map(myt[2]->a[0:10])
1530 {
1531 myt[2]->a[2]++;
1532 }
1533
1534 #pragma omp target map(myt[2]->b[0:10])
1535 {
1536 myt[2]->b[2]++;
1537 }
1538
1539 #pragma omp target enter data map(to: myt[2]->c)
1540
1541 #pragma omp target map(myt[2]->c[0:10])
1542 {
1543 myt[2]->c[2]++;
1544 }
1545
1546 #pragma omp target exit data map(from: myt[2]->c)
1547
1548 #pragma omp target enter data map(to: myt[2]->d)
1549
1550 #pragma omp target map(myt[2]->d[0:10])
1551 {
1552 myt[2]->d[2]++;
1553 }
1554
1555 #pragma omp target exit data map(from: myt[0:3], myt[2]->d)
1556
1557 assert (myt[2]->a[2] == 1);
1558 assert (myt[2]->b[2] == 3);
1559 assert (myt[2]->c[2] == 3);
1560 assert (myt[2]->d[2] == 3);
1561 }
1562 #endif
1563
1564 #ifdef PTRPTR_OFFSET_DECL_MEMBER_SLICE_BASEPTR
1565 void
1566 ptrptr_offset_decl_member_slice_baseptr (void)
1567 {
1568 int c[10];
1569 int *d = &c[0];
1570 T myt_real(c, &c[0], d);
1571 T *myt_ptrarr[4] =
1572 {
1573 0,
1574 0,
1575 0,
1576 &myt_real
1577 };
1578 T **myt = &myt_ptrarr[0];
1579
1580 memset (c, 0, sizeof c);
1581
1582 #pragma omp target map(to:myt[3], myt[3]->c) map(myt[3]->c[0:10])
1583 {
1584 myt[3]->c[2]++;
1585 }
1586
1587 #pragma omp target map(to:myt[3], myt[3]->d) map(myt[3]->d[0:10])
1588 {
1589 myt[3]->d[2]++;
1590 }
1591
1592 #pragma omp target map(to:myt, myt[3], myt[3]->c) map(myt[3]->c[0:10])
1593 {
1594 myt[3]->c[2]++;
1595 }
1596
1597 #pragma omp target map(to:myt, myt[3], myt[3]->d) map(myt[3]->d[0:10])
1598 {
1599 myt[3]->d[2]++;
1600 }
1601
1602 assert (myt[3]->c[2] == 4);
1603 assert (myt[3]->d[2] == 4);
1604 }
1605 #endif
1606
1607 #ifdef REF2PTRPTR_OFFSET_DECL_MEMBER_SLICE
1608 void
1609 ref2ptrptr_offset_decl_member_slice (void)
1610 {
1611 int c[10];
1612 int *d = &c[0];
1613 T myt_real(c, &c[0], d);
1614 T *myt_ptrarr[4] =
1615 {
1616 0,
1617 0,
1618 &myt_real,
1619 0
1620 };
1621 T **myt_ptrptr = &myt_ptrarr[0];
1622 T **&myt = myt_ptrptr;
1623
1624 memset (c, 0, sizeof c);
1625
1626 /* NOTE: It's possible that this should work without explicitly
1627 mapping "myt" here, allowing it to be implicitly
1628 mapped "firstprivate" by the "omp target" directive
1629 below. That doesn't work for now though (see comment
1630 in gimplify.cc:gimplify_adjust_omp_clauses_1). See also
1631 ptrptr_offset_decl_member_slice above (where the explicit mapping
1632 can be omitted). */
1633 #pragma omp target enter data map(to: myt, myt[0:3])
1634
1635 #pragma omp target map(myt[2]->a[0:10])
1636 {
1637 myt[2]->a[2]++;
1638 }
1639
1640 #pragma omp target map(myt[2]->b[0:10])
1641 {
1642 myt[2]->b[2]++;
1643 }
1644
1645 #pragma omp target enter data map(to:myt[2]->c)
1646
1647 #pragma omp target map(myt[2]->c[0:10])
1648 {
1649 myt[2]->c[2]++;
1650 }
1651
1652 #pragma omp target exit data map(release:myt[2]->c)
1653
1654 #pragma omp target enter data map(to:myt[2]->d)
1655
1656 #pragma omp target map(myt[2]->d[0:10])
1657 {
1658 myt[2]->d[2]++;
1659 }
1660
1661 #pragma omp target exit data map(release: myt, myt[0:3], myt[2]->d)
1662
1663 assert (myt[2]->a[2] == 1);
1664 assert (myt[2]->b[2] == 3);
1665 assert (myt[2]->c[2] == 3);
1666 assert (myt[2]->d[2] == 3);
1667 }
1668 #endif
1669
1670 #ifdef REF2PTRPTR_OFFSET_DECL_MEMBER_SLICE_BASEPTR
1671 void
1672 ref2ptrptr_offset_decl_member_slice_baseptr (void)
1673 {
1674 int c[10];
1675 int *d = &c[0];
1676 T myt_real(c, &c[0], d);
1677 T *myt_ptrarr[4] =
1678 {
1679 0,
1680 0,
1681 &myt_real,
1682 0
1683 };
1684 T **myt_ptrptr = &myt_ptrarr[0];
1685 T **&myt = myt_ptrptr;
1686
1687 memset (c, 0, sizeof c);
1688
1689 #pragma omp target map(to:myt[2], myt[2]->c) map(myt[2]->c[0:10])
1690 {
1691 myt[2]->c[2]++;
1692 }
1693
1694 #pragma omp target map(to:myt[2], myt[2]->d) map(myt[2]->d[0:10])
1695 {
1696 myt[2]->d[2]++;
1697 }
1698
1699 #pragma omp target map(to:myt, myt[2], myt[2]->c) map(myt[2]->c[0:10])
1700 {
1701 myt[2]->c[2]++;
1702 }
1703
1704 #pragma omp target map(to:myt, myt[2], myt[2]->d) map(myt[2]->d[0:10])
1705 {
1706 myt[2]->d[2]++;
1707 }
1708
1709 assert (myt[2]->c[2] == 4);
1710 assert (myt[2]->d[2] == 4);
1711 }
1712 #endif
1713
1714 struct U
1715 {
1716 S s1;
1717 T t1;
1718 S &s2;
1719 T &t2;
1720 S *s3;
1721 T *t3;
1722 S *&s4;
1723 T *&t4;
1724
1725 U(S &sptr1, T &tptr1, S &sptr2, T &tptr2, S *sptr3, T *tptr3,
1726 S *&sptr4, T *&tptr4)
1727 : s1(sptr1), t1(tptr1), s2(sptr2), t2(tptr2), s3(sptr3), t3(tptr3),
1728 s4(sptr4), t4(tptr4)
1729 {
1730 }
1731 };
1732
1733 #define INIT_S(N) \
1734 int a##N = 0, b##N = 0, c##N = 0, d##N = 0; \
1735 int *d##N##ptr = &d##N; \
1736 S s##N(a##N, b##N, &c##N, d##N##ptr)
1737
1738 #define INIT_T(N) \
1739 int arr##N[10]; \
1740 int *ptr##N = &arr##N[0]; \
1741 T t##N(arr##N, &arr##N[0], ptr##N); \
1742 memset (arr##N, 0, sizeof arr##N)
1743
1744 #define INIT_ST \
1745 INIT_S(1); \
1746 INIT_T(1); \
1747 INIT_S(2); \
1748 INIT_T(2); \
1749 INIT_S(3); \
1750 INIT_T(3); \
1751 int a4 = 0, b4 = 0, c4 = 0, d4 = 0; \
1752 int *d4ptr = &d4; \
1753 S *s4 = new S(a4, b4, &c4, d4ptr); \
1754 int arr4[10]; \
1755 int *ptr4 = &arr4[0]; \
1756 T *t4 = new T(arr4, &arr4[0], ptr4); \
1757 memset (arr4, 0, sizeof arr4)
1758
1759 #ifdef NONREF_COMPONENT_BASE
1760 void
1761 nonref_component_base (void)
1762 {
1763 INIT_ST;
1764 U myu(s1, t1, s2, t2, &s3, &t3, s4, t4);
1765
1766 #pragma omp target map(myu.s1.a, myu.s1.b, myu.s1.c, myu.s1.d)
1767 {
1768 myu.s1.a++;
1769 myu.s1.b++;
1770 myu.s1.c++;
1771 myu.s1.d++;
1772 }
1773
1774 assert (myu.s1.a == 1);
1775 assert (myu.s1.b == 1);
1776 assert (myu.s1.c == &c1 + 1);
1777 assert (myu.s1.d == &d1 + 1);
1778
1779 #pragma omp target map(myu.s2.a, myu.s2.b, myu.s2.c, myu.s2.d)
1780 {
1781 myu.s2.a++;
1782 myu.s2.b++;
1783 myu.s2.c++;
1784 myu.s2.d++;
1785 }
1786
1787 assert (myu.s2.a == 1);
1788 assert (myu.s2.b == 1);
1789 assert (myu.s2.c == &c2 + 1);
1790 assert (myu.s2.d == &d2 + 1);
1791
1792 #pragma omp target map(to:myu.s3) \
1793 map(myu.s3->a, myu.s3->b, myu.s3->c, myu.s3->d)
1794 {
1795 myu.s3->a++;
1796 myu.s3->b++;
1797 myu.s3->c++;
1798 myu.s3->d++;
1799 }
1800
1801 assert (myu.s3->a == 1);
1802 assert (myu.s3->b == 1);
1803 assert (myu.s3->c == &c3 + 1);
1804 assert (myu.s3->d == &d3 + 1);
1805
1806 #pragma omp target map(to:myu.s4) \
1807 map(myu.s4->a, myu.s4->b, myu.s4->c, myu.s4->d)
1808 {
1809 myu.s4->a++;
1810 myu.s4->b++;
1811 myu.s4->c++;
1812 myu.s4->d++;
1813 }
1814
1815 assert (myu.s4->a == 1);
1816 assert (myu.s4->b == 1);
1817 assert (myu.s4->c == &c4 + 1);
1818 assert (myu.s4->d == &d4 + 1);
1819
1820 delete s4;
1821 delete t4;
1822 }
1823 #endif
1824
1825 #ifdef NONREF_COMPONENT_MEMBER_SLICE
1826 void
1827 nonref_component_member_slice (void)
1828 {
1829 INIT_ST;
1830 U myu(s1, t1, s2, t2, &s3, &t3, s4, t4);
1831
1832 #pragma omp target map(myu.t1.a[2:5])
1833 {
1834 myu.t1.a[2]++;
1835 }
1836
1837 #pragma omp target map(myu.t1.b[2:5])
1838 {
1839 myu.t1.b[2]++;
1840 }
1841
1842 #pragma omp target enter data map(to: myu.t1.c)
1843
1844 #pragma omp target map(myu.t1.c[2:5])
1845 {
1846 myu.t1.c[2]++;
1847 }
1848
1849 #pragma omp target exit data map(release: myu.t1.c)
1850
1851 #pragma omp target enter data map(to: myu.t1.d)
1852
1853 #pragma omp target map(myu.t1.d[2:5])
1854 {
1855 myu.t1.d[2]++;
1856 }
1857
1858 #pragma omp target exit data map(from: myu.t1.d)
1859
1860 assert (myu.t1.a[2] == 1);
1861 assert (myu.t1.b[2] == 3);
1862 assert (myu.t1.c[2] == 3);
1863 assert (myu.t1.d[2] == 3);
1864
1865 #pragma omp target map(myu.t2.a[2:5])
1866 {
1867 myu.t2.a[2]++;
1868 }
1869
1870 #pragma omp target map(myu.t2.b[2:5])
1871 {
1872 myu.t2.b[2]++;
1873 }
1874
1875 #pragma omp target enter data map(to: myu.t2.c)
1876
1877 #pragma omp target map(myu.t2.c[2:5])
1878 {
1879 myu.t2.c[2]++;
1880 }
1881
1882 #pragma omp target exit data map(release: myu.t2.c)
1883
1884 #pragma omp target enter data map(to: myu.t2.d)
1885
1886 #pragma omp target map(myu.t2.d[2:5])
1887 {
1888 myu.t2.d[2]++;
1889 }
1890
1891 #pragma omp target exit data map(release: myu.t2.d)
1892
1893 assert (myu.t2.a[2] == 1);
1894 assert (myu.t2.b[2] == 3);
1895 assert (myu.t2.c[2] == 3);
1896 assert (myu.t2.d[2] == 3);
1897
1898 #pragma omp target enter data map(to: myu.t3)
1899
1900 #pragma omp target map(myu.t3->a[2:5])
1901 {
1902 myu.t3->a[2]++;
1903 }
1904
1905 #pragma omp target map(myu.t3->b[2:5])
1906 {
1907 myu.t3->b[2]++;
1908 }
1909
1910 #pragma omp target enter data map(to: myu.t3->c)
1911
1912 #pragma omp target map(myu.t3->c[2:5])
1913 {
1914 myu.t3->c[2]++;
1915 }
1916
1917 #pragma omp target exit data map(release: myu.t3->c)
1918
1919 #pragma omp target enter data map(to: myu.t3->d)
1920
1921 #pragma omp target map(myu.t3->d[2:5])
1922 {
1923 myu.t3->d[2]++;
1924 }
1925
1926 #pragma omp target exit data map(release: myu.t3, myu.t3->d)
1927
1928 assert (myu.t3->a[2] == 1);
1929 assert (myu.t3->b[2] == 3);
1930 assert (myu.t3->c[2] == 3);
1931 assert (myu.t3->d[2] == 3);
1932
1933 #pragma omp target enter data map(to: myu.t4)
1934
1935 #pragma omp target map(myu.t4->a[2:5])
1936 {
1937 myu.t4->a[2]++;
1938 }
1939
1940 #pragma omp target map(myu.t4->b[2:5])
1941 {
1942 myu.t4->b[2]++;
1943 }
1944
1945 #pragma omp target enter data map(to: myu.t4->c)
1946
1947 #pragma omp target map(myu.t4->c[2:5])
1948 {
1949 myu.t4->c[2]++;
1950 }
1951
1952 #pragma omp target exit data map(release: myu.t4->c)
1953
1954 #pragma omp target enter data map(to: myu.t4->d)
1955
1956 #pragma omp target map(myu.t4->d[2:5])
1957 {
1958 myu.t4->d[2]++;
1959 }
1960
1961 #pragma omp target exit data map(release: myu.t4, myu.t4->d)
1962
1963 assert (myu.t4->a[2] == 1);
1964 assert (myu.t4->b[2] == 3);
1965 assert (myu.t4->c[2] == 3);
1966 assert (myu.t4->d[2] == 3);
1967
1968 delete s4;
1969 delete t4;
1970 }
1971 #endif
1972
1973 #ifdef NONREF_COMPONENT_MEMBER_SLICE_BASEPTR
1974 void
1975 nonref_component_member_slice_baseptr (void)
1976 {
1977 INIT_ST;
1978 U myu(s1, t1, s2, t2, &s3, &t3, s4, t4);
1979
1980 #pragma omp target map(to: myu.t1.c) map(myu.t1.c[2:5])
1981 {
1982 myu.t1.c[2]++;
1983 }
1984
1985 #pragma omp target map(to: myu.t1.d) map(myu.t1.d[2:5])
1986 {
1987 myu.t1.d[2]++;
1988 }
1989
1990 assert (myu.t1.c[2] == 2);
1991 assert (myu.t1.d[2] == 2);
1992
1993 #pragma omp target map(to: myu.t2.c) map(myu.t2.c[2:5])
1994 {
1995 myu.t2.c[2]++;
1996 }
1997
1998 #pragma omp target map(to: myu.t2.d) map(myu.t2.d[2:5])
1999 {
2000 myu.t2.d[2]++;
2001 }
2002
2003 assert (myu.t2.c[2] == 2);
2004 assert (myu.t2.d[2] == 2);
2005
2006 #pragma omp target map(to: myu.t3, myu.t3->c) map(myu.t3->c[2:5])
2007 {
2008 myu.t3->c[2]++;
2009 }
2010
2011 #pragma omp target map(to: myu.t3, myu.t3->d) map(myu.t3->d[2:5])
2012 {
2013 myu.t3->d[2]++;
2014 }
2015
2016 assert (myu.t3->c[2] == 2);
2017 assert (myu.t3->d[2] == 2);
2018
2019 #pragma omp target map(to: myu.t4, myu.t4->c) map(myu.t4->c[2:5])
2020 {
2021 myu.t4->c[2]++;
2022 }
2023
2024 #pragma omp target map(to: myu.t4, myu.t4->d) map(myu.t4->d[2:5])
2025 {
2026 myu.t4->d[2]++;
2027 }
2028
2029 assert (myu.t4->c[2] == 2);
2030 assert (myu.t4->d[2] == 2);
2031
2032 delete s4;
2033 delete t4;
2034 }
2035 #endif
2036
2037 #ifdef REF_COMPONENT_BASE
2038 void
2039 ref_component_base (void)
2040 {
2041 INIT_ST;
2042 U myu_real(s1, t1, s2, t2, &s3, &t3, s4, t4);
2043 U &myu = myu_real;
2044
2045 #pragma omp target map(myu.s1.a, myu.s1.b, myu.s1.c, myu.s1.d)
2046 {
2047 myu.s1.a++;
2048 myu.s1.b++;
2049 myu.s1.c++;
2050 myu.s1.d++;
2051 }
2052
2053 assert (myu.s1.a == 1);
2054 assert (myu.s1.b == 1);
2055 assert (myu.s1.c == &c1 + 1);
2056 assert (myu.s1.d == &d1 + 1);
2057
2058 #pragma omp target map(myu.s2.a, myu.s2.b, myu.s2.c, myu.s2.d)
2059 {
2060 myu.s2.a++;
2061 myu.s2.b++;
2062 myu.s2.c++;
2063 myu.s2.d++;
2064 }
2065
2066 assert (myu.s2.a == 1);
2067 assert (myu.s2.b == 1);
2068 assert (myu.s2.c == &c2 + 1);
2069 assert (myu.s2.d == &d2 + 1);
2070
2071 #pragma omp target map(to:myu.s3) \
2072 map(myu.s3->a, myu.s3->b, myu.s3->c, myu.s3->d)
2073 {
2074 myu.s3->a++;
2075 myu.s3->b++;
2076 myu.s3->c++;
2077 myu.s3->d++;
2078 }
2079
2080 assert (myu.s3->a == 1);
2081 assert (myu.s3->b == 1);
2082 assert (myu.s3->c == &c3 + 1);
2083 assert (myu.s3->d == &d3 + 1);
2084
2085 #pragma omp target map(to:myu.s4) \
2086 map(myu.s4->a, myu.s4->b, myu.s4->c, myu.s4->d)
2087 {
2088 myu.s4->a++;
2089 myu.s4->b++;
2090 myu.s4->c++;
2091 myu.s4->d++;
2092 }
2093
2094 assert (myu.s4->a == 1);
2095 assert (myu.s4->b == 1);
2096 assert (myu.s4->c == &c4 + 1);
2097 assert (myu.s4->d == &d4 + 1);
2098
2099 delete s4;
2100 delete t4;
2101 }
2102 #endif
2103
2104 #ifdef REF_COMPONENT_MEMBER_SLICE
2105 void
2106 ref_component_member_slice (void)
2107 {
2108 INIT_ST;
2109 U myu_real(s1, t1, s2, t2, &s3, &t3, s4, t4);
2110 U &myu = myu_real;
2111
2112 #pragma omp target map(myu.t1.a[2:5])
2113 {
2114 myu.t1.a[2]++;
2115 }
2116
2117 #pragma omp target map(myu.t1.b[2:5])
2118 {
2119 myu.t1.b[2]++;
2120 }
2121
2122 #pragma omp target enter data map(to: myu.t1.c)
2123
2124 #pragma omp target map(myu.t1.c[2:5])
2125 {
2126 myu.t1.c[2]++;
2127 }
2128
2129 #pragma omp target exit data map(release: myu.t1.c)
2130
2131 #pragma omp target enter data map(to: myu.t1.d)
2132
2133 #pragma omp target map(myu.t1.d[2:5])
2134 {
2135 myu.t1.d[2]++;
2136 }
2137
2138 #pragma omp target exit data map(release: myu.t1.d)
2139
2140 assert (myu.t1.a[2] == 1);
2141 assert (myu.t1.b[2] == 3);
2142 assert (myu.t1.c[2] == 3);
2143 assert (myu.t1.d[2] == 3);
2144
2145 #pragma omp target map(myu.t2.a[2:5])
2146 {
2147 myu.t2.a[2]++;
2148 }
2149
2150 #pragma omp target map(myu.t2.b[2:5])
2151 {
2152 myu.t2.b[2]++;
2153 }
2154
2155 #pragma omp target enter data map(to: myu.t2.c)
2156
2157 #pragma omp target map(myu.t2.c[2:5])
2158 {
2159 myu.t2.c[2]++;
2160 }
2161
2162 #pragma omp target exit data map(release: myu.t2.c)
2163
2164 #pragma omp target enter data map(to: myu.t2.d)
2165
2166 #pragma omp target map(myu.t2.d[2:5])
2167 {
2168 myu.t2.d[2]++;
2169 }
2170
2171 #pragma omp target exit data map(release: myu.t2.d)
2172
2173 assert (myu.t2.a[2] == 1);
2174 assert (myu.t2.b[2] == 3);
2175 assert (myu.t2.c[2] == 3);
2176 assert (myu.t2.d[2] == 3);
2177
2178 #pragma omp target enter data map(to: myu.t3)
2179
2180 #pragma omp target map(myu.t3->a[2:5])
2181 {
2182 myu.t3->a[2]++;
2183 }
2184
2185 #pragma omp target map(myu.t3->b[2:5])
2186 {
2187 myu.t3->b[2]++;
2188 }
2189
2190 #pragma omp target enter data map(to: myu.t3->c)
2191
2192 #pragma omp target map(myu.t3->c[2:5])
2193 {
2194 myu.t3->c[2]++;
2195 }
2196
2197 #pragma omp target exit data map(release: myu.t3->c)
2198
2199 #pragma omp target enter data map(to: myu.t3->d)
2200
2201 #pragma omp target map(myu.t3->d[2:5])
2202 {
2203 myu.t3->d[2]++;
2204 }
2205
2206 #pragma omp target exit data map(release: myu.t3, myu.t3->d)
2207
2208 assert (myu.t3->a[2] == 1);
2209 assert (myu.t3->b[2] == 3);
2210 assert (myu.t3->c[2] == 3);
2211 assert (myu.t3->d[2] == 3);
2212
2213 #pragma omp target enter data map(to: myu.t4)
2214
2215 #pragma omp target map(myu.t4->a[2:5])
2216 {
2217 myu.t4->a[2]++;
2218 }
2219
2220 #pragma omp target map(myu.t4->b[2:5])
2221 {
2222 myu.t4->b[2]++;
2223 }
2224
2225 #pragma omp target enter data map(to: myu.t4->c)
2226
2227 #pragma omp target map(myu.t4->c[2:5])
2228 {
2229 myu.t4->c[2]++;
2230 }
2231
2232 #pragma omp target exit data map(release: myu.t4->c)
2233
2234 #pragma omp target enter data map(to: myu.t4->d)
2235
2236 #pragma omp target map(myu.t4->d[2:5])
2237 {
2238 myu.t4->d[2]++;
2239 }
2240
2241 #pragma omp target exit data map(release: myu.t4, myu.t4->d)
2242
2243 assert (myu.t4->a[2] == 1);
2244 assert (myu.t4->b[2] == 3);
2245 assert (myu.t4->c[2] == 3);
2246 assert (myu.t4->d[2] == 3);
2247
2248 delete s4;
2249 delete t4;
2250 }
2251 #endif
2252
2253 #ifdef REF_COMPONENT_MEMBER_SLICE_BASEPTR
2254 void
2255 ref_component_member_slice_baseptr (void)
2256 {
2257 INIT_ST;
2258 U myu_real(s1, t1, s2, t2, &s3, &t3, s4, t4);
2259 U &myu = myu_real;
2260
2261 #pragma omp target map(to: myu.t1.c) map(myu.t1.c[2:5])
2262 {
2263 myu.t1.c[2]++;
2264 }
2265
2266 #pragma omp target map(to: myu.t1.d) map(myu.t1.d[2:5])
2267 {
2268 myu.t1.d[2]++;
2269 }
2270
2271 assert (myu.t1.c[2] == 2);
2272 assert (myu.t1.d[2] == 2);
2273
2274 #pragma omp target map(to: myu.t2.c) map(myu.t2.c[2:5])
2275 {
2276 myu.t2.c[2]++;
2277 }
2278
2279 #pragma omp target map(to: myu.t2.d) map(myu.t2.d[2:5])
2280 {
2281 myu.t2.d[2]++;
2282 }
2283
2284 assert (myu.t2.c[2] == 2);
2285 assert (myu.t2.d[2] == 2);
2286
2287 #pragma omp target map(to: myu.t3, myu.t3->c) map(myu.t3->c[2:5])
2288 {
2289 myu.t3->c[2]++;
2290 }
2291
2292 #pragma omp target map(to: myu.t3, myu.t3->d) map(myu.t3->d[2:5])
2293 {
2294 myu.t3->d[2]++;
2295 }
2296
2297 assert (myu.t3->c[2] == 2);
2298 assert (myu.t3->d[2] == 2);
2299
2300 #pragma omp target map(to: myu.t4, myu.t4->c) map(myu.t4->c[2:5])
2301 {
2302 myu.t4->c[2]++;
2303 }
2304
2305 #pragma omp target map(to: myu.t4, myu.t4->d) map(myu.t4->d[2:5])
2306 {
2307 myu.t4->d[2]++;
2308 }
2309
2310 assert (myu.t4->c[2] == 2);
2311 assert (myu.t4->d[2] == 2);
2312
2313 delete s4;
2314 delete t4;
2315 }
2316 #endif
2317
2318 #ifdef PTR_COMPONENT_BASE
2319 void
2320 ptr_component_base (void)
2321 {
2322 INIT_ST;
2323 U *myu = new U(s1, t1, s2, t2, &s3, &t3, s4, t4);
2324
2325 #pragma omp target map(myu->s1.a, myu->s1.b, myu->s1.c, myu->s1.d)
2326 {
2327 myu->s1.a++;
2328 myu->s1.b++;
2329 myu->s1.c++;
2330 myu->s1.d++;
2331 }
2332
2333 assert (myu->s1.a == 1);
2334 assert (myu->s1.b == 1);
2335 assert (myu->s1.c == &c1 + 1);
2336 assert (myu->s1.d == &d1 + 1);
2337
2338 #pragma omp target map(myu->s2.a, myu->s2.b, myu->s2.c, myu->s2.d)
2339 {
2340 myu->s2.a++;
2341 myu->s2.b++;
2342 myu->s2.c++;
2343 myu->s2.d++;
2344 }
2345
2346 assert (myu->s2.a == 1);
2347 assert (myu->s2.b == 1);
2348 assert (myu->s2.c == &c2 + 1);
2349 assert (myu->s2.d == &d2 + 1);
2350
2351 #pragma omp target map(to:myu->s3) \
2352 map(myu->s3->a, myu->s3->b, myu->s3->c, myu->s3->d)
2353 {
2354 myu->s3->a++;
2355 myu->s3->b++;
2356 myu->s3->c++;
2357 myu->s3->d++;
2358 }
2359
2360 assert (myu->s3->a == 1);
2361 assert (myu->s3->b == 1);
2362 assert (myu->s3->c == &c3 + 1);
2363 assert (myu->s3->d == &d3 + 1);
2364
2365 #pragma omp target map(to:myu->s4) \
2366 map(myu->s4->a, myu->s4->b, myu->s4->c, myu->s4->d)
2367 {
2368 myu->s4->a++;
2369 myu->s4->b++;
2370 myu->s4->c++;
2371 myu->s4->d++;
2372 }
2373
2374 assert (myu->s4->a == 1);
2375 assert (myu->s4->b == 1);
2376 assert (myu->s4->c == &c4 + 1);
2377 assert (myu->s4->d == &d4 + 1);
2378
2379 delete s4;
2380 delete t4;
2381 delete myu;
2382 }
2383 #endif
2384
2385 #ifdef PTR_COMPONENT_MEMBER_SLICE
2386 void
2387 ptr_component_member_slice (void)
2388 {
2389 INIT_ST;
2390 U *myu = new U(s1, t1, s2, t2, &s3, &t3, s4, t4);
2391
2392 #pragma omp target map(myu->t1.a[2:5])
2393 {
2394 myu->t1.a[2]++;
2395 }
2396
2397 #pragma omp target map(myu->t1.b[2:5])
2398 {
2399 myu->t1.b[2]++;
2400 }
2401
2402 #pragma omp target enter data map(to: myu->t1.c)
2403
2404 #pragma omp target map(myu->t1.c[2:5])
2405 {
2406 myu->t1.c[2]++;
2407 }
2408
2409 #pragma omp target exit data map(release: myu->t1.c)
2410
2411 #pragma omp target enter data map(to: myu->t1.d)
2412
2413 #pragma omp target map(myu->t1.d[2:5])
2414 {
2415 myu->t1.d[2]++;
2416 }
2417
2418 #pragma omp target exit data map(release: myu->t1.d)
2419
2420 assert (myu->t1.a[2] == 1);
2421 assert (myu->t1.b[2] == 3);
2422 assert (myu->t1.c[2] == 3);
2423 assert (myu->t1.d[2] == 3);
2424
2425 #pragma omp target map(myu->t2.a[2:5])
2426 {
2427 myu->t2.a[2]++;
2428 }
2429
2430 #pragma omp target map(myu->t2.b[2:5])
2431 {
2432 myu->t2.b[2]++;
2433 }
2434
2435 #pragma omp target enter data map(to: myu->t2.c)
2436
2437 #pragma omp target map(myu->t2.c[2:5])
2438 {
2439 myu->t2.c[2]++;
2440 }
2441
2442 #pragma omp target exit data map(release: myu->t2.c)
2443
2444 #pragma omp target enter data map(to: myu->t2.d)
2445
2446 #pragma omp target map(myu->t2.d[2:5])
2447 {
2448 myu->t2.d[2]++;
2449 }
2450
2451 #pragma omp target exit data map(release: myu->t2.d)
2452
2453 assert (myu->t2.a[2] == 1);
2454 assert (myu->t2.b[2] == 3);
2455 assert (myu->t2.c[2] == 3);
2456 assert (myu->t2.d[2] == 3);
2457
2458 #pragma omp target enter data map(to: myu->t3)
2459
2460 #pragma omp target map(myu->t3->a[2:5])
2461 {
2462 myu->t3->a[2]++;
2463 }
2464
2465 #pragma omp target map(myu->t3->b[2:5])
2466 {
2467 myu->t3->b[2]++;
2468 }
2469
2470 #pragma omp target enter data map(to: myu->t3->c)
2471
2472 #pragma omp target map(myu->t3->c[2:5])
2473 {
2474 myu->t3->c[2]++;
2475 }
2476
2477 #pragma omp target exit data map(release: myu->t3->c)
2478
2479 #pragma omp target enter data map(to: myu->t3->d)
2480
2481 #pragma omp target map(myu->t3->d[2:5])
2482 {
2483 myu->t3->d[2]++;
2484 }
2485
2486 #pragma omp target exit data map(release: myu->t3, myu->t3->d)
2487
2488 assert (myu->t3->a[2] == 1);
2489 assert (myu->t3->b[2] == 3);
2490 assert (myu->t3->c[2] == 3);
2491 assert (myu->t3->d[2] == 3);
2492
2493 #pragma omp target enter data map(to: myu->t4)
2494
2495 #pragma omp target map(myu->t4->a[2:5])
2496 {
2497 myu->t4->a[2]++;
2498 }
2499
2500 #pragma omp target map(myu->t4->b[2:5])
2501 {
2502 myu->t4->b[2]++;
2503 }
2504
2505 #pragma omp target enter data map(to: myu->t4->c)
2506
2507 #pragma omp target map(myu->t4->c[2:5])
2508 {
2509 myu->t4->c[2]++;
2510 }
2511
2512 #pragma omp target exit data map(release: myu->t4->c)
2513
2514 #pragma omp target enter data map(to: myu->t4->d)
2515
2516 #pragma omp target map(myu->t4->d[2:5])
2517 {
2518 myu->t4->d[2]++;
2519 }
2520
2521 #pragma omp target exit data map(release: myu->t4, myu->t4->d)
2522
2523 assert (myu->t4->a[2] == 1);
2524 assert (myu->t4->b[2] == 3);
2525 assert (myu->t4->c[2] == 3);
2526 assert (myu->t4->d[2] == 3);
2527
2528 delete s4;
2529 delete t4;
2530 delete myu;
2531 }
2532 #endif
2533
2534 #ifdef PTR_COMPONENT_MEMBER_SLICE_BASEPTR
2535 void
2536 ptr_component_member_slice_baseptr (void)
2537 {
2538 INIT_ST;
2539 U *myu = new U(s1, t1, s2, t2, &s3, &t3, s4, t4);
2540
2541 /* Implicit firstprivate 'myu'. */
2542 #pragma omp target map(to: myu->t1.c) map(myu->t1.c[2:5])
2543 {
2544 myu->t1.c[2]++;
2545 }
2546
2547 #pragma omp target map(to: myu->t1.d) map(myu->t1.d[2:5])
2548 {
2549 myu->t1.d[2]++;
2550 }
2551
2552 assert (myu->t1.c[2] == 2);
2553 assert (myu->t1.d[2] == 2);
2554
2555 /* Explicitly-mapped 'myu'. */
2556 #pragma omp target map(to: myu, myu->t1.c) map(myu->t1.c[2:5])
2557 {
2558 myu->t1.c[2]++;
2559 }
2560
2561 #pragma omp target map(to: myu, myu->t1.d) map(myu->t1.d[2:5])
2562 {
2563 myu->t1.d[2]++;
2564 }
2565
2566 assert (myu->t1.c[2] == 4);
2567 assert (myu->t1.d[2] == 4);
2568
2569 /* Implicit firstprivate 'myu'. */
2570 #pragma omp target map(to: myu->t2.c) map(myu->t2.c[2:5])
2571 {
2572 myu->t2.c[2]++;
2573 }
2574
2575 #pragma omp target map(to: myu->t2.d) map(myu->t2.d[2:5])
2576 {
2577 myu->t2.d[2]++;
2578 }
2579
2580 assert (myu->t2.c[2] == 2);
2581 assert (myu->t2.d[2] == 2);
2582
2583 /* Explicitly-mapped 'myu'. */
2584 #pragma omp target map(to: myu, myu->t2.c) map(myu->t2.c[2:5])
2585 {
2586 myu->t2.c[2]++;
2587 }
2588
2589 #pragma omp target map(to: myu, myu->t2.d) map(myu->t2.d[2:5])
2590 {
2591 myu->t2.d[2]++;
2592 }
2593
2594 assert (myu->t2.c[2] == 4);
2595 assert (myu->t2.d[2] == 4);
2596
2597 /* Implicit firstprivate 'myu'. */
2598 #pragma omp target map(to: myu->t3, myu->t3->c) map(myu->t3->c[2:5])
2599 {
2600 myu->t3->c[2]++;
2601 }
2602
2603 #pragma omp target map(to: myu->t3, myu->t3->d) map(myu->t3->d[2:5])
2604 {
2605 myu->t3->d[2]++;
2606 }
2607
2608 assert (myu->t3->c[2] == 2);
2609 assert (myu->t3->d[2] == 2);
2610
2611 /* Explicitly-mapped 'myu'. */
2612 #pragma omp target map(to: myu, myu->t3, myu->t3->c) map(myu->t3->c[2:5])
2613 {
2614 myu->t3->c[2]++;
2615 }
2616
2617 #pragma omp target map(to: myu, myu->t3, myu->t3->d) map(myu->t3->d[2:5])
2618 {
2619 myu->t3->d[2]++;
2620 }
2621
2622 assert (myu->t3->c[2] == 4);
2623 assert (myu->t3->d[2] == 4);
2624
2625 /* Implicit firstprivate 'myu'. */
2626 #pragma omp target map(to: myu->t4, myu->t4->c) map(myu->t4->c[2:5])
2627 {
2628 myu->t4->c[2]++;
2629 }
2630
2631 #pragma omp target map(to: myu->t4, myu->t4->d) map(myu->t4->d[2:5])
2632 {
2633 myu->t4->d[2]++;
2634 }
2635
2636 assert (myu->t4->c[2] == 2);
2637 assert (myu->t4->d[2] == 2);
2638
2639 /* Explicitly-mapped 'myu'. */
2640 #pragma omp target map(to: myu, myu->t4, myu->t4->c) map(myu->t4->c[2:5])
2641 {
2642 myu->t4->c[2]++;
2643 }
2644
2645 #pragma omp target map(to: myu, myu->t4, myu->t4->d) map(myu->t4->d[2:5])
2646 {
2647 myu->t4->d[2]++;
2648 }
2649
2650 assert (myu->t4->c[2] == 4);
2651 assert (myu->t4->d[2] == 4);
2652
2653 delete s4;
2654 delete t4;
2655 delete myu;
2656 }
2657 #endif
2658
2659 #ifdef REF2PTR_COMPONENT_BASE
2660 void
2661 ref2ptr_component_base (void)
2662 {
2663 INIT_ST;
2664 U *myu_ptr = new U(s1, t1, s2, t2, &s3, &t3, s4, t4);
2665 U *&myu = myu_ptr;
2666
2667 #pragma omp target map(myu->s1.a, myu->s1.b, myu->s1.c, myu->s1.d)
2668 {
2669 myu->s1.a++;
2670 myu->s1.b++;
2671 myu->s1.c++;
2672 myu->s1.d++;
2673 }
2674
2675 assert (myu->s1.a == 1);
2676 assert (myu->s1.b == 1);
2677 assert (myu->s1.c == &c1 + 1);
2678 assert (myu->s1.d == &d1 + 1);
2679
2680 #pragma omp target map(myu->s2.a, myu->s2.b, myu->s2.c, myu->s2.d)
2681 {
2682 myu->s2.a++;
2683 myu->s2.b++;
2684 myu->s2.c++;
2685 myu->s2.d++;
2686 }
2687
2688 assert (myu->s2.a == 1);
2689 assert (myu->s2.b == 1);
2690 assert (myu->s2.c == &c2 + 1);
2691 assert (myu->s2.d == &d2 + 1);
2692
2693 #pragma omp target map(to:myu->s3) \
2694 map(myu->s3->a, myu->s3->b, myu->s3->c, myu->s3->d)
2695 {
2696 myu->s3->a++;
2697 myu->s3->b++;
2698 myu->s3->c++;
2699 myu->s3->d++;
2700 }
2701
2702 assert (myu->s3->a == 1);
2703 assert (myu->s3->b == 1);
2704 assert (myu->s3->c == &c3 + 1);
2705 assert (myu->s3->d == &d3 + 1);
2706
2707 #pragma omp target map(to:myu->s4) \
2708 map(myu->s4->a, myu->s4->b, myu->s4->c, myu->s4->d)
2709 {
2710 myu->s4->a++;
2711 myu->s4->b++;
2712 myu->s4->c++;
2713 myu->s4->d++;
2714 }
2715
2716 assert (myu->s4->a == 1);
2717 assert (myu->s4->b == 1);
2718 assert (myu->s4->c == &c4 + 1);
2719 assert (myu->s4->d == &d4 + 1);
2720
2721 delete s4;
2722 delete t4;
2723 delete myu_ptr;
2724 }
2725 #endif
2726
2727 #ifdef REF2PTR_COMPONENT_MEMBER_SLICE
2728 void
2729 ref2ptr_component_member_slice (void)
2730 {
2731 INIT_ST;
2732 U *myu_ptr = new U(s1, t1, s2, t2, &s3, &t3, s4, t4);
2733 U *&myu = myu_ptr;
2734
2735 #pragma omp target map(myu->t1.a[2:5])
2736 {
2737 myu->t1.a[2]++;
2738 }
2739
2740 #pragma omp target map(myu->t1.b[2:5])
2741 {
2742 myu->t1.b[2]++;
2743 }
2744
2745 #pragma omp target enter data map(to: myu->t1.c)
2746
2747 #pragma omp target map(myu->t1.c[2:5])
2748 {
2749 myu->t1.c[2]++;
2750 }
2751
2752 #pragma omp target exit data map(release: myu->t1.c)
2753
2754 #pragma omp target enter data map(to: myu->t1.d)
2755
2756 #pragma omp target map(myu->t1.d[2:5])
2757 {
2758 myu->t1.d[2]++;
2759 }
2760
2761 #pragma omp target exit data map(release: myu->t1.d)
2762
2763 assert (myu->t1.a[2] == 1);
2764 assert (myu->t1.b[2] == 3);
2765 assert (myu->t1.c[2] == 3);
2766 assert (myu->t1.d[2] == 3);
2767
2768 #pragma omp target map(myu->t2.a[2:5])
2769 {
2770 myu->t2.a[2]++;
2771 }
2772
2773 #pragma omp target map(myu->t2.b[2:5])
2774 {
2775 myu->t2.b[2]++;
2776 }
2777
2778 #pragma omp target enter data map(to: myu->t2.c)
2779
2780 #pragma omp target map(myu->t2.c[2:5])
2781 {
2782 myu->t2.c[2]++;
2783 }
2784
2785 #pragma omp target exit data map(release: myu->t2.c)
2786
2787 #pragma omp target enter data map(to: myu->t2.d)
2788
2789 #pragma omp target map(myu->t2.d[2:5])
2790 {
2791 myu->t2.d[2]++;
2792 }
2793
2794 #pragma omp target exit data map(release: myu->t2.d)
2795
2796 assert (myu->t2.a[2] == 1);
2797 assert (myu->t2.b[2] == 3);
2798 assert (myu->t2.c[2] == 3);
2799 assert (myu->t2.d[2] == 3);
2800
2801 #pragma omp target enter data map(to: myu->t3)
2802
2803 #pragma omp target map(myu->t3->a[2:5])
2804 {
2805 myu->t3->a[2]++;
2806 }
2807
2808 #pragma omp target map(myu->t3->b[2:5])
2809 {
2810 myu->t3->b[2]++;
2811 }
2812
2813 #pragma omp target enter data map(to: myu->t3->c)
2814
2815 #pragma omp target map(myu->t3->c[2:5])
2816 {
2817 myu->t3->c[2]++;
2818 }
2819
2820 #pragma omp target exit data map(release: myu->t3->c)
2821
2822 #pragma omp target enter data map(to: myu->t3->d)
2823
2824 #pragma omp target map(myu->t3->d[2:5])
2825 {
2826 myu->t3->d[2]++;
2827 }
2828
2829 #pragma omp target exit data map(release: myu->t3, myu->t3->d)
2830
2831 assert (myu->t3->a[2] == 1);
2832 assert (myu->t3->b[2] == 3);
2833 assert (myu->t3->c[2] == 3);
2834 assert (myu->t3->d[2] == 3);
2835
2836 #pragma omp target enter data map(to: myu->t4)
2837
2838 #pragma omp target map(myu->t4->a[2:5])
2839 {
2840 myu->t4->a[2]++;
2841 }
2842
2843 #pragma omp target map(myu->t4->b[2:5])
2844 {
2845 myu->t4->b[2]++;
2846 }
2847
2848 #pragma omp target enter data map(to: myu->t4->c)
2849
2850 #pragma omp target map(myu->t4->c[2:5])
2851 {
2852 myu->t4->c[2]++;
2853 }
2854
2855 #pragma omp target exit data map(release: myu->t4->c)
2856
2857 #pragma omp target enter data map(to: myu->t4->d)
2858
2859 #pragma omp target map(myu->t4->d[2:5])
2860 {
2861 myu->t4->d[2]++;
2862 }
2863
2864 #pragma omp target exit data map(release: myu->t4, myu->t4->d)
2865
2866 assert (myu->t4->a[2] == 1);
2867 assert (myu->t4->b[2] == 3);
2868 assert (myu->t4->c[2] == 3);
2869 assert (myu->t4->d[2] == 3);
2870
2871 delete s4;
2872 delete t4;
2873 delete myu_ptr;
2874 }
2875 #endif
2876
2877 #ifdef REF2PTR_COMPONENT_MEMBER_SLICE_BASEPTR
2878 void
2879 ref2ptr_component_member_slice_baseptr (void)
2880 {
2881 INIT_ST;
2882 U *myu_ptr = new U(s1, t1, s2, t2, &s3, &t3, s4, t4);
2883 U *&myu = myu_ptr;
2884
2885 /* Implicit firstprivate 'myu'. */
2886 #pragma omp target map(to: myu->t1.c) map(myu->t1.c[2:5])
2887 {
2888 myu->t1.c[2]++;
2889 }
2890
2891 #pragma omp target map(to: myu->t1.d) map(myu->t1.d[2:5])
2892 {
2893 myu->t1.d[2]++;
2894 }
2895
2896 assert (myu->t1.c[2] == 2);
2897 assert (myu->t1.d[2] == 2);
2898
2899 /* Explicitly-mapped 'myu'. */
2900 #pragma omp target map(to: myu, myu->t1.c) map(myu->t1.c[2:5])
2901 {
2902 myu->t1.c[2]++;
2903 }
2904
2905 #pragma omp target map(to: myu, myu->t1.d) map(myu->t1.d[2:5])
2906 {
2907 myu->t1.d[2]++;
2908 }
2909
2910 assert (myu->t1.c[2] == 4);
2911 assert (myu->t1.d[2] == 4);
2912
2913 /* Implicit firstprivate 'myu'. */
2914 #pragma omp target map(to: myu->t2.c) map(myu->t2.c[2:5])
2915 {
2916 myu->t2.c[2]++;
2917 }
2918
2919 #pragma omp target map(to: myu->t2.d) map(myu->t2.d[2:5])
2920 {
2921 myu->t2.d[2]++;
2922 }
2923
2924 assert (myu->t2.c[2] == 2);
2925 assert (myu->t2.d[2] == 2);
2926
2927 /* Explicitly-mapped 'myu'. */
2928 #pragma omp target map(to: myu, myu->t2.c) map(myu->t2.c[2:5])
2929 {
2930 myu->t2.c[2]++;
2931 }
2932
2933 #pragma omp target map(to: myu, myu->t2.d) map(myu->t2.d[2:5])
2934 {
2935 myu->t2.d[2]++;
2936 }
2937
2938 assert (myu->t2.c[2] == 4);
2939 assert (myu->t2.d[2] == 4);
2940
2941 /* Implicit firstprivate 'myu'. */
2942 #pragma omp target map(to: myu->t3, myu->t3->c) map(myu->t3->c[2:5])
2943 {
2944 myu->t3->c[2]++;
2945 }
2946
2947 #pragma omp target map(to: myu->t3, myu->t3->d) map(myu->t3->d[2:5])
2948 {
2949 myu->t3->d[2]++;
2950 }
2951
2952 assert (myu->t3->c[2] == 2);
2953 assert (myu->t3->d[2] == 2);
2954
2955 /* Explicitly-mapped 'myu'. */
2956 #pragma omp target map(to: myu, myu->t3, myu->t3->c) map(myu->t3->c[2:5])
2957 {
2958 myu->t3->c[2]++;
2959 }
2960
2961 #pragma omp target map(to: myu, myu->t3, myu->t3->d) map(myu->t3->d[2:5])
2962 {
2963 myu->t3->d[2]++;
2964 }
2965
2966 assert (myu->t3->c[2] == 4);
2967 assert (myu->t3->d[2] == 4);
2968
2969 /* Implicit firstprivate 'myu'. */
2970 #pragma omp target map(to: myu->t4, myu->t4->c) map(myu->t4->c[2:5])
2971 {
2972 myu->t4->c[2]++;
2973 }
2974
2975 #pragma omp target map(to: myu->t4, myu->t4->d) map(myu->t4->d[2:5])
2976 {
2977 myu->t4->d[2]++;
2978 }
2979
2980 assert (myu->t4->c[2] == 2);
2981 assert (myu->t4->d[2] == 2);
2982
2983 /* Explicitly-mapped 'myu'. */
2984 #pragma omp target map(to: myu, myu->t4, myu->t4->c) map(myu->t4->c[2:5])
2985 {
2986 myu->t4->c[2]++;
2987 }
2988
2989 #pragma omp target map(to: myu, myu->t4, myu->t4->d) map(myu->t4->d[2:5])
2990 {
2991 myu->t4->d[2]++;
2992 }
2993
2994 assert (myu->t4->c[2] == 4);
2995 assert (myu->t4->d[2] == 4);
2996
2997 delete s4;
2998 delete t4;
2999 delete myu_ptr;
3000 }
3001 #endif
3002
3003 int main (int argc, char *argv[])
3004 {
3005 #ifdef MAP_DECLS
3006 map_decls ();
3007 #endif
3008
3009 #ifdef NONREF_DECL_BASE
3010 nonref_decl_base ();
3011 #endif
3012 #ifdef REF_DECL_BASE
3013 ref_decl_base ();
3014 #endif
3015 #ifdef PTR_DECL_BASE
3016 ptr_decl_base ();
3017 #endif
3018 #ifdef REF2PTR_DECL_BASE
3019 ref2ptr_decl_base ();
3020 #endif
3021
3022 #ifdef ARRAY_DECL_BASE
3023 array_decl_base ();
3024 #endif
3025 #ifdef REF2ARRAY_DECL_BASE
3026 ref2array_decl_base ();
3027 #endif
3028 #ifdef PTR_OFFSET_DECL_BASE
3029 ptr_offset_decl_base ();
3030 #endif
3031 #ifdef REF2PTR_OFFSET_DECL_BASE
3032 ref2ptr_offset_decl_base ();
3033 #endif
3034
3035 #ifdef MAP_SECTIONS
3036 map_sections ();
3037 #endif
3038
3039 #ifdef NONREF_DECL_MEMBER_SLICE
3040 nonref_decl_member_slice ();
3041 #endif
3042 #ifdef NONREF_DECL_MEMBER_SLICE_BASEPTR
3043 nonref_decl_member_slice_baseptr ();
3044 #endif
3045 #ifdef REF_DECL_MEMBER_SLICE
3046 ref_decl_member_slice ();
3047 #endif
3048 #ifdef REF_DECL_MEMBER_SLICE_BASEPTR
3049 ref_decl_member_slice_baseptr ();
3050 #endif
3051 #ifdef PTR_DECL_MEMBER_SLICE
3052 ptr_decl_member_slice ();
3053 #endif
3054 #ifdef PTR_DECL_MEMBER_SLICE_BASEPTR
3055 ptr_decl_member_slice_baseptr ();
3056 #endif
3057 #ifdef REF2PTR_DECL_MEMBER_SLICE
3058 ref2ptr_decl_member_slice ();
3059 #endif
3060 #ifdef REF2PTR_DECL_MEMBER_SLICE_BASEPTR
3061 ref2ptr_decl_member_slice_baseptr ();
3062 #endif
3063
3064 #ifdef ARRAY_DECL_MEMBER_SLICE
3065 array_decl_member_slice ();
3066 #endif
3067 #ifdef ARRAY_DECL_MEMBER_SLICE_BASEPTR
3068 array_decl_member_slice_baseptr ();
3069 #endif
3070 #ifdef REF2ARRAY_DECL_MEMBER_SLICE
3071 ref2array_decl_member_slice ();
3072 #endif
3073 #ifdef REF2ARRAY_DECL_MEMBER_SLICE_BASEPTR
3074 ref2array_decl_member_slice_baseptr ();
3075 #endif
3076 #ifdef PTR_OFFSET_DECL_MEMBER_SLICE
3077 ptr_offset_decl_member_slice ();
3078 #endif
3079 #ifdef PTR_OFFSET_DECL_MEMBER_SLICE_BASEPTR
3080 ptr_offset_decl_member_slice_baseptr ();
3081 #endif
3082 #ifdef REF2PTR_OFFSET_DECL_MEMBER_SLICE
3083 ref2ptr_offset_decl_member_slice ();
3084 #endif
3085 #ifdef REF2PTR_OFFSET_DECL_MEMBER_SLICE_BASEPTR
3086 ref2ptr_offset_decl_member_slice_baseptr ();
3087 #endif
3088
3089 #ifdef PTRARRAY_DECL_MEMBER_SLICE
3090 ptrarray_decl_member_slice ();
3091 #endif
3092 #ifdef PTRARRAY_DECL_MEMBER_SLICE_BASEPTR
3093 ptrarray_decl_member_slice_baseptr ();
3094 #endif
3095 #ifdef REF2PTRARRAY_DECL_MEMBER_SLICE
3096 ref2ptrarray_decl_member_slice ();
3097 #endif
3098 #ifdef REF2PTRARRAY_DECL_MEMBER_SLICE_BASEPTR
3099 ref2ptrarray_decl_member_slice_baseptr ();
3100 #endif
3101 #ifdef PTRPTR_OFFSET_DECL_MEMBER_SLICE
3102 ptrptr_offset_decl_member_slice ();
3103 #endif
3104 #ifdef PTRPTR_OFFSET_DECL_MEMBER_SLICE_BASEPTR
3105 ptrptr_offset_decl_member_slice_baseptr ();
3106 #endif
3107 #ifdef REF2PTRPTR_OFFSET_DECL_MEMBER_SLICE
3108 ref2ptrptr_offset_decl_member_slice ();
3109 #endif
3110 #ifdef REF2PTRPTR_OFFSET_DECL_MEMBER_SLICE_BASEPTR
3111 ref2ptrptr_offset_decl_member_slice_baseptr ();
3112 #endif
3113
3114 #ifdef NONREF_COMPONENT_BASE
3115 nonref_component_base ();
3116 #endif
3117 #ifdef NONREF_COMPONENT_MEMBER_SLICE
3118 nonref_component_member_slice ();
3119 #endif
3120 #ifdef NONREF_COMPONENT_MEMBER_SLICE_BASEPTR
3121 nonref_component_member_slice_baseptr ();
3122 #endif
3123
3124 #ifdef REF_COMPONENT_BASE
3125 ref_component_base ();
3126 #endif
3127 #ifdef REF_COMPONENT_MEMBER_SLICE
3128 ref_component_member_slice ();
3129 #endif
3130 #ifdef REF_COMPONENT_MEMBER_SLICE_BASEPTR
3131 ref_component_member_slice_baseptr ();
3132 #endif
3133
3134 #ifdef PTR_COMPONENT_BASE
3135 ptr_component_base ();
3136 #endif
3137 #ifdef PTR_COMPONENT_MEMBER_SLICE
3138 ptr_component_member_slice ();
3139 #endif
3140 #ifdef PTR_COMPONENT_MEMBER_SLICE_BASEPTR
3141 ptr_component_member_slice_baseptr ();
3142 #endif
3143
3144 #ifdef REF2PTR_COMPONENT_BASE
3145 ref2ptr_component_base ();
3146 #endif
3147 #ifdef REF2PTR_COMPONENT_MEMBER_SLICE
3148 ref2ptr_component_member_slice ();
3149 #endif
3150 #ifdef REF2PTR_COMPONENT_MEMBER_SLICE_BASEPTR
3151 ref2ptr_component_member_slice_baseptr ();
3152 #endif
3153
3154 return 0;
3155 }