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