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