1 // RUN: %clang_cc1 -verify -fopenmp -ferror-limit 200 %s
2 // RUN: %clang_cc1 -DCCODE -verify -fopenmp -ferror-limit 200 -x c %s
3 #ifdef CCODE
4 void foo(int arg) {
5   const int n = 0;
6 
7   double marr[10][10][10];
8 
9   #pragma omp target map(marr[2][0:2][0:2]) // expected-error {{array section does not specify contiguous storage}}
10   {}
11   #pragma omp target map(marr[:][0:][:])
12   {}
13   #pragma omp target map(marr[:][1:][:]) // expected-error {{array section does not specify contiguous storage}}
14   {}
15   #pragma omp target map(marr[:][n:][:])
16   {}
17 }
18 #else
19 template <typename T, int I>
20 struct SA {
21   static int ss;
22   #pragma omp threadprivate(ss) // expected-note {{defined as threadprivate or thread local}}
23   float a;
24   int b[12];
25   float *c;
26   T d;
27   float e[I];
28   T *f;
29   int bf : 20;
30   void func(int arg) {
31     #pragma omp target
32     {
33       a = 0.0;
34       func(arg);
35       bf = 20;
36     }
37     #pragma omp target map(arg,a,d)
38     {}
39     #pragma omp target map(arg[2:2],a,d) // expected-error {{subscripted value is not an array or pointer}}
40     {}
41     #pragma omp target map(arg,a*2) // expected-error {{expected expression containing only member accesses and/or array sections based on named variables}}
42     {}
43     #pragma omp target map(arg,(c+1)[2]) // expected-error {{expected expression containing only member accesses and/or array sections based on named variables}}
44     {}
45     #pragma omp target map(arg,a[:2],d) // expected-error {{subscripted value is not an array or pointer}}
46     {}
47     #pragma omp target map(arg,a,d[:2]) // expected-error {{subscripted value is not an array or pointer}}
48     {}
49 
50     #pragma omp target map(to:ss) // expected-error {{threadprivate variables are not allowed in 'map' clause}}
51     {}
52 
53     #pragma omp target map(to:b,e)
54     {}
55     #pragma omp target map(to:b,e) map(to:b) // expected-error {{variable already marked as mapped in current construct}} expected-note {{used here}}
56     {}
57     #pragma omp target map(to:b[:2],e)
58     {}
59     #pragma omp target map(to:b,e[:])
60     {}
61     #pragma omp target map(b[-1:]) // expected-error {{array section must be a subset of the original array}}
62     {}
63     #pragma omp target map(b[:-1]) // expected-error {{section length is evaluated to a negative value -1}}
64     {}
65 
66     #pragma omp target map(always, tofrom: c,f)
67     {}
68     #pragma omp target map(always, tofrom: c[1:2],f)
69     {}
70     #pragma omp target map(always, tofrom: c,f[1:2])
71     {}
72     #pragma omp target map(always, tofrom: c[:],f)   // expected-error {{section length is unspecified and cannot be inferred because subscripted value is not an array}}
73     {}
74     #pragma omp target map(always, tofrom: c,f[:])   // expected-error {{section length is unspecified and cannot be inferred because subscripted value is not an array}}
75     {}
76     #pragma omp target map(always)   // expected-error {{use of undeclared identifier 'always'}}
77     {}
78     return;
79   }
80 };
81 
82 struct SB {
83   unsigned A;
84   unsigned B;
85   float Arr[100];
86   float *Ptr;
87   float *foo() {
88     return &Arr[0];
89   }
90 };
91 
92 struct SC {
93   unsigned A : 2;
94   unsigned B : 3;
95   unsigned C;
96   unsigned D;
97   float Arr[100];
98   SB S;
99   SB ArrS[100];
100   SB *PtrS;
101   SB *&RPtrS;
102   float *Ptr;
103 
104   SC(SB *&_RPtrS) : RPtrS(_RPtrS) {}
105 };
106 
107 union SD {
108   unsigned A;
109   float B;
110 };
111 
112 void SAclient(int arg) {
113   SA<int,123> s;
114   s.func(arg); // expected-note {{in instantiation of member function}}
115   double marr[10][10][10];
116   double marr2[5][10][1];
117   double mvla[5][arg][10];
118   double ***mptr;
119   const int n = 0;
120   const int m = 1;
121   double mvla2[5][arg][m+n+10];
122 
123   SB *p;
124 
125   SD u;
126   SC r(p),t(p);
127   #pragma omp target map(r)
128   {}
129   #pragma omp target map(marr[2][0:2][0:2]) // expected-error {{array section does not specify contiguous storage}}
130   {}
131   #pragma omp target map(marr[:][0:2][0:2]) // expected-error {{array section does not specify contiguous storage}}
132   {}
133   #pragma omp target map(marr[2][3][0:2])
134   {}
135   #pragma omp target map(marr[:][:][:])
136   {}
137   #pragma omp target map(marr[:2][:][:])
138   {}
139   #pragma omp target map(marr[arg:][:][:])
140   {}
141   #pragma omp target map(marr[arg:])
142   {}
143   #pragma omp target map(marr[arg:][:arg][:]) // correct if arg is the size of dimension 2
144   {}
145   #pragma omp target map(marr[:arg][:])
146   {}
147   #pragma omp target map(marr[:arg][n:])
148   {}
149   #pragma omp target map(marr[:][:arg][n:]) // correct if arg is the size of  dimension 2
150   {}
151   #pragma omp target map(marr[:][:m][n:]) // expected-error {{array section does not specify contiguous storage}}
152   {}
153   #pragma omp target map(marr[n:m][:arg][n:])
154   {}
155   #pragma omp target map(marr[:2][:1][:]) // expected-error {{array section does not specify contiguous storage}}
156   {}
157   #pragma omp target map(marr[:2][1:][:]) // expected-error {{array section does not specify contiguous storage}}
158   {}
159   #pragma omp target map(marr[:2][:][:1]) // expected-error {{array section does not specify contiguous storage}}
160   {}
161   #pragma omp target map(marr[:2][:][1:]) // expected-error {{array section does not specify contiguous storage}}
162   {}
163   #pragma omp target map(marr[:1][:2][:])
164   {}
165   #pragma omp target map(marr[:1][0][:])
166   {}
167   #pragma omp target map(marr[:arg][:2][:]) // correct if arg is 1
168   {}
169   #pragma omp target map(marr[:1][3:1][:2])
170   {}
171   #pragma omp target map(marr[:1][3:arg][:2]) // correct if arg is 1
172   {}
173   #pragma omp target map(marr[:1][3:2][:2]) // expected-error {{array section does not specify contiguous storage}}
174   {}
175   #pragma omp target map(marr[:2][:10][:])
176   {}
177   #pragma omp target map(marr[:2][:][:5+5])
178   {}
179   #pragma omp target map(marr[:2][2+2-4:][0:5+5])
180   {}
181 
182   #pragma omp target map(marr[:1][:2][0]) // expected-error {{array section does not specify contiguous storage}}
183   {}
184   #pragma omp target map(marr2[:1][:2][0])
185   {}
186 
187   #pragma omp target map(mvla[:1][:][0]) // correct if the size of dimension 2 is 1.
188   {}
189   #pragma omp target map(mvla[:2][:arg][:]) // correct if arg is the size of dimension 2.
190   {}
191   #pragma omp target map(mvla[:1][:2][0]) // expected-error {{array section does not specify contiguous storage}}
192    {}
193   #pragma omp target map(mvla[1][2:arg][:])
194   {}
195   #pragma omp target map(mvla[:1][:][:])
196   {}
197   #pragma omp target map(mvla2[:1][:2][:11])
198   {}
199   #pragma omp target map(mvla2[:1][:2][:10]) // expected-error {{array section does not specify contiguous storage}}
200   {}
201 
202   #pragma omp target map(mptr[:2][2+2-4:1][0:5+5]) // expected-error {{array section does not specify contiguous storage}}
203   {}
204   #pragma omp target map(mptr[:1][:2-1][2:4-3])
205   {}
206   #pragma omp target map(mptr[:1][:arg][2:4-3]) // correct if arg is 1.
207   {}
208   #pragma omp target map(mptr[:1][:2-1][0:2])
209   {}
210   #pragma omp target map(mptr[:1][:2][0:2]) // expected-error {{array section does not specify contiguous storage}}
211   {}
212   #pragma omp target map(mptr[:1][:][0:2]) // expected-error {{section length is unspecified and cannot be inferred because subscripted value is not an array}}
213   {}
214   #pragma omp target map(mptr[:2][:1][0:2]) // expected-error {{array section does not specify contiguous storage}}
215   {}
216 
217   #pragma omp target map(r.ArrS[0].B)
218   {}
219   #pragma omp target map(r.ArrS[:1].B) // expected-error {{OpenMP array section is not allowed here}}
220   {}
221   #pragma omp target map(r.ArrS[:arg].B) // expected-error {{OpenMP array section is not allowed here}}
222   {}
223   #pragma omp target map(r.ArrS[0].Arr[1:23])
224   {}
225   #pragma omp target map(r.ArrS[0].Arr[1:arg])
226   {}
227   #pragma omp target map(r.ArrS[0].Arr[arg:23])
228   {}
229   #pragma omp target map(r.ArrS[0].Error) // expected-error {{no member named 'Error' in 'SB'}}
230   {}
231   #pragma omp target map(r.ArrS[0].A, r.ArrS[1].A) // expected-error {{multiple array elements associated with the same variable are not allowed in map clauses of the same construct}} expected-note {{used here}}
232   {}
233   #pragma omp target map(r.ArrS[0].A, t.ArrS[1].A)
234   {}
235   #pragma omp target map(r.PtrS[0], r.PtrS->B) // expected-error {{same pointer derreferenced in multiple different ways in map clause expressions}} expected-note {{used here}}
236   {}
237   #pragma omp target map(r.RPtrS[0], r.RPtrS->B) // expected-error {{same pointer derreferenced in multiple different ways in map clause expressions}} expected-note {{used here}}
238   {}
239   #pragma omp target map(r.S.Arr[:12])
240   {}
241   #pragma omp target map(r.S.foo()[:12]) // expected-error {{expected expression containing only member accesses and/or array sections based on named variables}}
242   {}
243   #pragma omp target map(r.C, r.D)
244   {}
245   #pragma omp target map(r.C, r.C) // expected-error {{variable already marked as mapped in current construct}} expected-note {{used here}}
246   {}
247   #pragma omp target map(r.C) map(r.C) // expected-error {{variable already marked as mapped in current construct}} expected-note {{used here}}
248   {}
249   #pragma omp target map(r.C, r.S)  // this would be an error only caught at runtime - Sema would have to make sure there is not way for the missing data between fields to be mapped somewhere else.
250   {}
251   #pragma omp target map(r, r.S)  // expected-error {{variable already marked as mapped in current construct}} expected-note {{used here}}
252   {}
253   #pragma omp target map(r.C, t.C)
254   {}
255   #pragma omp target map(r.A)   // expected-error {{bit fields cannot be used to specify storage in a 'map' clause}}
256   {}
257   #pragma omp target map(r.Arr)
258   {}
259   #pragma omp target map(r.Arr[3:5])
260   {}
261   #pragma omp target map(r.Ptr[3:5])
262   {}
263   #pragma omp target map(r.ArrS[3:5].A)   // expected-error {{OpenMP array section is not allowed here}}
264   {}
265   #pragma omp target map(r.ArrS[3:5].Arr[6:7])   // expected-error {{OpenMP array section is not allowed here}}
266   {}
267   #pragma omp target map(r.ArrS[3].Arr[6:7])
268   {}
269   #pragma omp target map(r.S.Arr[4:5])
270   {}
271   #pragma omp target map(r.S.Ptr[4:5])
272   {}
273   #pragma omp target map(r.S.Ptr[:])  // expected-error {{section length is unspecified and cannot be inferred because subscripted value is not an array}}
274   {}
275   #pragma omp target map((p+1)->A)  // expected-error {{expected expression containing only member accesses and/or array sections based on named variables}}
276   {}
277   #pragma omp target map(u.B)  // expected-error {{mapping of union members is not allowed}}
278   {}
279   #pragma omp target
280   {
281     u.B = 0;
282     r.S.foo();
283   }
284 
285   #pragma omp target data map(to: r.C) //expected-note {{used here}}
286   {
287     #pragma omp target map(r.D)  // expected-error {{original storage of expression in data environment is shared but data environment do not fully contain mapped expression storage}}
288     {}
289   }
290 
291   #pragma omp target data map(to: t.Ptr) //expected-note {{used here}}
292   {
293     #pragma omp target map(t.Ptr[:23])  // expected-error {{pointer cannot be mapped along with a section derived from itself}}
294     {}
295   }
296 
297   #pragma omp target data map(to: t.C, t.D)
298   {
299   #pragma omp target data map(to: t.C)
300   {
301     #pragma omp target map(t.D)
302     {}
303   }
304   }
305   #pragma omp target data map(marr[:][:][:])
306   {
307     #pragma omp target data map(marr)
308     {}
309   }
310 
311   #pragma omp target data map(to: t)
312   {
313   #pragma omp target data map(to: t.C)
314   {
315     #pragma omp target map(t.D)
316     {}
317   }
318   }
319 }
320 void foo() {
321 }
322 
323 bool foobool(int argc) {
324   return argc;
325 }
326 
327 struct S1; // expected-note 2 {{declared here}}
328 extern S1 a;
329 class S2 {
330   mutable int a;
331 public:
332   S2():a(0) { }
333   S2(S2 &s2):a(s2.a) { }
334   static float S2s;
335   static const float S2sc;
336 };
337 const float S2::S2sc = 0;
338 const S2 b;
339 const S2 ba[5];
340 class S3 {
341   int a;
342 public:
343   S3():a(0) { }
344   S3(S3 &s3):a(s3.a) { }
345 };
346 const S3 c;
347 const S3 ca[5];
348 extern const int f;
349 class S4 {
350   int a;
351   S4();
352   S4(const S4 &s4);
353 public:
354   S4(int v):a(v) { }
355 };
356 class S5 {
357   int a;
358   S5():a(0) {}
359   S5(const S5 &s5):a(s5.a) { }
360 public:
361   S5(int v):a(v) { }
362 };
363 
364 template <class T>
365 struct S6;
366 
367 template<>
368 struct S6<int>
369 {
370    virtual void foo();
371 };
372 
373 S3 h;
374 #pragma omp threadprivate(h) // expected-note 2 {{defined as threadprivate or thread local}}
375 
376 typedef int from;
377 
378 template <typename T, int I> // expected-note {{declared here}}
379 T tmain(T argc) {
380   const T d = 5;
381   const T da[5] = { 0 };
382   S4 e(4);
383   S5 g(5);
384   T i, t[20];
385   T &j = i;
386   T *k = &j;
387   T x;
388   T y;
389   T to, tofrom, always;
390   const T (&l)[5] = da;
391 #pragma omp target map // expected-error {{expected '(' after 'map'}}
392   {}
393 #pragma omp target map( // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{expected expression}}
394   {}
395 #pragma omp target map() // expected-error {{expected expression}}
396   {}
397 #pragma omp target map(alloc) // expected-error {{use of undeclared identifier 'alloc'}}
398   {}
399 #pragma omp target map(to argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{expected ',' or ')' in 'map' clause}}
400   {}
401 #pragma omp target map(to:) // expected-error {{expected expression}}
402   {}
403 #pragma omp target map(from: argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
404   {}
405 #pragma omp target map(x: y) // expected-error {{incorrect map type, expected one of 'to', 'from', 'tofrom', 'alloc', 'release', or 'delete'}}
406   {}
407 #pragma omp target map(x)
408   foo();
409 #pragma omp target map(tofrom: t[:I])
410   foo();
411 #pragma omp target map(T: a) // expected-error {{incorrect map type, expected one of 'to', 'from', 'tofrom', 'alloc', 'release', or 'delete'}} expected-error {{incomplete type 'S1' where a complete type is required}}
412   foo();
413 #pragma omp target map(T) // expected-error {{'T' does not refer to a value}}
414   foo();
415 #pragma omp target map(I) // expected-error 2 {{expected expression containing only member accesses and/or array sections based on named variables}}
416   foo();
417 #pragma omp target map(S2::S2s)
418   foo();
419 #pragma omp target map(S2::S2sc)
420   foo();
421 #pragma omp target map(x)
422   foo();
423 #pragma omp target map(to: x)
424   foo();
425 #pragma omp target map(to: to)
426   foo();
427 #pragma omp target map(to)
428   foo();
429 #pragma omp target map(to, x)
430   foo();
431 #pragma omp target data map(to x) // expected-error {{expected ',' or ')' in 'map' clause}}
432 #pragma omp target data map(tofrom: argc > 0 ? x : y) // expected-error 2 {{expected expression containing only member accesses and/or array sections based on named variables}}
433 #pragma omp target data map(argc)
434 #pragma omp target data map(S1) // expected-error {{'S1' does not refer to a value}}
435 #pragma omp target data map(a, b, c, d, f) // expected-error {{incomplete type 'S1' where a complete type is required}}
436 #pragma omp target data map(ba)
437 #pragma omp target data map(ca)
438 #pragma omp target data map(da)
439 #pragma omp target data map(S2::S2s)
440 #pragma omp target data map(S2::S2sc)
441 #pragma omp target data map(e, g)
442 #pragma omp target data map(h) // expected-error {{threadprivate variables are not allowed in 'map' clause}}
443 #pragma omp target data map(k) map(k) // expected-error 2 {{variable already marked as mapped in current construct}} expected-note 2 {{used here}}
444 #pragma omp target map(k), map(k[:5]) // expected-error 2 {{pointer cannot be mapped along with a section derived from itself}} expected-note 2 {{used here}}
445   foo();
446 #pragma omp target data map(da)
447 #pragma omp target map(da[:4])
448   foo();
449 #pragma omp target data map(k, j, l) // expected-note 2 {{used here}}
450 #pragma omp target data map(k[:4]) // expected-error 2 {{pointer cannot be mapped along with a section derived from itself}}
451 #pragma omp target data map(j)
452 #pragma omp target map(l) map(l[:5]) // expected-error 2 {{variable already marked as mapped in current construct}} expected-note 2 {{used here}}
453   foo();
454 #pragma omp target data map(k[:4], j, l[:5]) // expected-note 2 {{used here}}
455 #pragma omp target data map(k) // expected-error 2 {{pointer cannot be mapped along with a section derived from itself}}
456 #pragma omp target data map(j)
457 #pragma omp target map(l)
458   foo();
459 
460 #pragma omp target data map(always, tofrom: x)
461 #pragma omp target data map(always: x) // expected-error {{missing map type}}
462 #pragma omp target data map(tofrom, always: x) // expected-error {{incorrect map type modifier, expected 'always'}} expected-error {{incorrect map type, expected one of 'to', 'from', 'tofrom', 'alloc', 'release', or 'delete'}}
463 #pragma omp target data map(always, tofrom: always, tofrom, x)
464 #pragma omp target map(tofrom j) // expected-error {{expected ',' or ')' in 'map' clause}}
465   foo();
466   return 0;
467 }
468 
469 struct SA1{
470   int a;
471   struct SA1 *p;
472   int b[10];
473 };
474 struct SB1{
475   int a;
476   struct SA1 s;
477   struct SA1 sa[10];
478   struct SA1 *sp[10];
479   struct SA1 *p;
480 };
481 struct SC1{
482   int a;
483   struct SB1 s;
484   struct SB1 *p;
485   int b[10];
486 };
487 
488 int main(int argc, char **argv) {
489   const int d = 5;
490   const int da[5] = { 0 };
491   S4 e(4);
492   S5 g(5);
493   int i;
494   int &j = i;
495   int *k = &j;
496   S6<int> m;
497   int x;
498   int y;
499   int to, tofrom, always;
500   const int (&l)[5] = da;
501   SC1 s;
502   SC1 *p;
503 #pragma omp target data map // expected-error {{expected '(' after 'map'}} expected-error {{expected at least one 'map' or 'use_device_ptr' clause for '#pragma omp target data'}}
504 #pragma omp target data map( // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{expected expression}}
505 #pragma omp target data map() // expected-error {{expected expression}}
506 #pragma omp target data map(alloc) // expected-error {{use of undeclared identifier 'alloc'}}
507 #pragma omp target data map(to argc // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error {{expected ',' or ')' in 'map' clause}}
508 #pragma omp target data map(to:) // expected-error {{expected expression}}
509 #pragma omp target data map(from: argc, // expected-error {{expected expression}} expected-error {{expected ')'}} expected-note {{to match this '('}}
510 #pragma omp target data map(x: y) // expected-error {{incorrect map type, expected one of 'to', 'from', 'tofrom', 'alloc', 'release', or 'delete'}}
511 #pragma omp target map(x)
512   foo();
513 #pragma omp target map(to: x)
514   foo();
515 #pragma omp target map(to: to)
516   foo();
517 #pragma omp target map(to)
518   foo();
519 #pragma omp target map(to, x)
520   foo();
521 #pragma omp target data map(to x) // expected-error {{expected ',' or ')' in 'map' clause}}
522 #pragma omp target data map(tofrom: argc > 0 ? argv[1] : argv[2]) // expected-error {{xpected expression containing only member accesses and/or array sections based on named variables}}
523 #pragma omp target data map(argc)
524 #pragma omp target data map(S1) // expected-error {{'S1' does not refer to a value}}
525 #pragma omp target data map(a, b, c, d, f) // expected-error {{incomplete type 'S1' where a complete type is required}}
526 #pragma omp target data map(argv[1])
527 #pragma omp target data map(ba)
528 #pragma omp target data map(ca)
529 #pragma omp target data map(da)
530 #pragma omp target data map(S2::S2s)
531 #pragma omp target data map(S2::S2sc)
532 #pragma omp target data map(e, g)
533 #pragma omp target data map(h) // expected-error {{threadprivate variables are not allowed in 'map' clause}}
534 #pragma omp target data map(k), map(k) // expected-error {{variable already marked as mapped in current construct}} expected-note {{used here}}
535 #pragma omp target map(k), map(k[:5]) // expected-error {{pointer cannot be mapped along with a section derived from itself}} expected-note {{used here}}
536   foo();
537 #pragma omp target data map(da)
538 #pragma omp target map(da[:4])
539   foo();
540 #pragma omp target data map(k, j, l) // expected-note {{used here}}
541 #pragma omp target data map(k[:4]) // expected-error {{pointer cannot be mapped along with a section derived from itself}}
542 #pragma omp target data map(j)
543 #pragma omp target map(l) map(l[:5]) // expected-error {{variable already marked as mapped in current construct}} expected-note {{used here}}
544   foo();
545 #pragma omp target data map(k[:4], j, l[:5]) // expected-note {{used here}}
546 #pragma omp target data map(k) // expected-error {{pointer cannot be mapped along with a section derived from itself}}
547 #pragma omp target data map(j)
548 #pragma omp target map(l)
549   foo();
550 
551 #pragma omp target data map(always, tofrom: x)
552 #pragma omp target data map(always: x) // expected-error {{missing map type}}
553 #pragma omp target data map(tofrom, always: x) // expected-error {{incorrect map type modifier, expected 'always'}} expected-error {{incorrect map type, expected one of 'to', 'from', 'tofrom', 'alloc', 'release', or 'delete'}}
554 #pragma omp target data map(always, tofrom: always, tofrom, x)
555 #pragma omp target map(tofrom j) // expected-error {{expected ',' or ')' in 'map' clause}}
556   foo();
557 #pragma omp target private(j) map(j) // expected-error {{private variable cannot be in a map clause in '#pragma omp target' directive}}  expected-note {{defined as private}}
558   {}
559 #pragma omp target firstprivate(j) map(j)  // expected-error {{firstprivate variable cannot be in a map clause in '#pragma omp target' directive}} expected-note {{defined as firstprivate}}
560   {}
561 #pragma omp target map(m)
562   {}
563 // expected-note@+1 {{used here}}
564 #pragma omp target map(s.s.s)
565 // expected-error@+1 {{variable already marked as mapped in current construct}}
566   { s.a++; }
567 // expected-note@+1 {{used here}}
568 #pragma omp target map(s.s.s.a)
569 // expected-error@+1 {{variable already marked as mapped in current construct}}
570   { s.a++; }
571 // expected-note@+1 {{used here}}
572 #pragma omp target map(s.b[:5])
573 // expected-error@+1 {{variable already marked as mapped in current construct}}
574   { s.a++; }
575 // expected-note@+1 {{used here}}
576 #pragma omp target map(s.p[:5])
577 // expected-error@+1 {{variable already marked as mapped in current construct}}
578   { s.a++; }
579 // expected-note@+1 {{used here}}
580 #pragma omp target map(s.s.sa[3].a)
581 // expected-error@+1 {{variable already marked as mapped in current construct}}
582   { s.a++; }
583 // expected-note@+1 {{used here}}
584 #pragma omp target map(s.s.sp[3]->a)
585 // expected-error@+1 {{variable already marked as mapped in current construct}}
586   { s.a++; }
587 // expected-note@+1 {{used here}}
588 #pragma omp target map(s.p->a)
589 // expected-error@+1 {{variable already marked as mapped in current construct}}
590   { s.a++; }
591 // expected-note@+1 {{used here}}
592 #pragma omp target map(s.s.p->a)
593 // expected-error@+1 {{variable already marked as mapped in current construct}}
594   { s.a++; }
595 // expected-note@+1 {{used here}}
596 #pragma omp target map(s.s.s.b[:2])
597 // expected-error@+1 {{variable already marked as mapped in current construct}}
598   { s.a++; }
599 // expected-note@+1 {{used here}}
600 #pragma omp target map(s.s.p->b[:2])
601 // expected-error@+1 {{variable already marked as mapped in current construct}}
602   { s.a++; }
603 // expected-note@+1 {{used here}}
604 #pragma omp target map(s.p->p->p->a)
605 // expected-error@+1 {{variable already marked as mapped in current construct}}
606   { s.a++; }
607 #pragma omp target map(s.s.s.b[:2])
608   { s.s.s.b[0]++; }
609 
610   return tmain<int, 3>(argc)+tmain<from, 4>(argc); // expected-note {{in instantiation of function template specialization 'tmain<int, 3>' requested here}} expected-note {{in instantiation of function template specialization 'tmain<int, 4>' requested here}}
611 }
612 #endif
613