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