Debian Codegraph @

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

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