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