1 // RUN: %clang_cc1 -fsyntax-only -fopenmp -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify %s -Wuninitialized
2 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify %s -Wuninitialized
3 // RUN: %clang_cc1 -fsyntax-only -fopenmp -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify %s -fopenmp-version=50 -DOMP50 -Wuninitialized
4 // RUN: %clang_cc1 -fsyntax-only -fopenmp-simd -x c++ -std=c++11 -fexceptions -fcxx-exceptions -verify %s -fopenmp-version=50 -DOMP50 -Wuninitialized
5
6 static int sii;
7 // expected-note@+1 {{defined as threadprivate or thread local}}
8 #pragma omp threadprivate(sii)
9 static int globalii;
10
11 struct S {
12 // expected-note@+1 {{static data member is predetermined as shared}}
13 static int ssi;
14 };
15
test_iteration_spaces()16 int test_iteration_spaces() {
17 const int N = 100;
18 float a[N], b[N], c[N];
19 int ii, jj, kk;
20 float fii;
21 double dii;
22 #pragma omp simd linear(S::ssi)
23 for (S::ssi = 0; S::ssi < 10; ++S::ssi)
24 ;
25 // expected-error@+1 {{shared variable cannot be private}}
26 #pragma omp simd private(S::ssi)
27 for (S::ssi = 0; S::ssi < 10; ++S::ssi)
28 ;
29 #pragma omp simd // no messages expected
30 for (S::ssi = 0; S::ssi < 10; ++S::ssi)
31 ;
32 #pragma omp simd
33 for (int i = 0; i < 10; i+=1) {
34 c[i] = a[i] + b[i];
35 }
36 #pragma omp simd
37 for (char i = 0; i < 10; i++) {
38 c[i] = a[i] + b[i];
39 }
40 #pragma omp simd
41 for (char i = 0; i < 10; i+='\1') {
42 c[i] = a[i] + b[i];
43 }
44 #pragma omp simd
45 for (long long i = 0; i < 10; i++) {
46 c[i] = a[i] + b[i];
47 }
48 // expected-error@+2 {{expression must have integral or unscoped enumeration type, not 'double'}}
49 #pragma omp simd
50 for (long long i = 0; i < 10; i+=1.5) {
51 c[i] = a[i] + b[i];
52 }
53 #pragma omp simd
54 for (long long i = 0; i < 'z'; i+=1u) {
55 c[i] = a[i] + b[i];
56 }
57 // expected-error@+2 {{variable must be of integer or random access iterator type}}
58 #pragma omp simd
59 for (float fi = 0; fi < 10.0; fi++) {
60 c[(int)fi] = a[(int)fi] + b[(int)fi];
61 }
62 // expected-error@+2 {{variable must be of integer or random access iterator type}}
63 #pragma omp simd
64 for (double fi = 0; fi < 10.0; fi++) {
65 c[(int)fi] = a[(int)fi] + b[(int)fi];
66 }
67 // expected-error@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
68 #pragma omp simd
69 for (int &ref = ii; ref < 10; ref++) {
70 }
71 // expected-error@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
72 #pragma omp simd
73 for (int i; i < 10; i++)
74 c[i] = a[i];
75
76 // expected-error@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
77 #pragma omp simd
78 for (int i = 0, j = 0; i < 10; ++i)
79 c[i] = a[i];
80
81 // expected-error@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
82 #pragma omp simd
83 for (;ii < 10; ++ii)
84 c[ii] = a[ii];
85
86 // expected-warning@+3 {{expression result unused}}
87 // expected-error@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
88 #pragma omp simd
89 for (ii + 1;ii < 10; ++ii)
90 c[ii] = a[ii];
91
92 // expected-error@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
93 #pragma omp simd
94 for (c[ii] = 0;ii < 10; ++ii)
95 c[ii] = a[ii];
96
97 // Ok to skip parenthesises.
98 #pragma omp simd
99 for (((ii)) = 0;ii < 10; ++ii)
100 c[ii] = a[ii];
101
102 // expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}}
103 #pragma omp simd
104 for (int i = 0; i; i++)
105 c[i] = a[i];
106
107 // expected-error@+3 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}}
108 // expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'i'}}
109 #pragma omp simd
110 for (int i = 0; jj < kk; ii++)
111 c[i] = a[i];
112
113 // expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}}
114 #pragma omp simd
115 for (int i = 0; !!i; i++)
116 c[i] = a[i];
117
118 // Ok
119 #pragma omp simd
120 for (int i = 0; i != 1; i++)
121 c[i] = a[i];
122
123 // expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'i'}}
124 #pragma omp simd
125 for (int i = 0; ; i++)
126 c[i] = a[i];
127
128 // Ok.
129 #pragma omp simd
130 for (int i = 11; i > 10; i--)
131 c[i] = a[i];
132
133 // Ok.
134 #pragma omp simd
135 for (int i = 0; i < 10; ++i)
136 c[i] = a[i];
137
138 // Ok.
139 #pragma omp simd
140 for (ii = 0; ii < 10; ++ii)
141 c[ii] = a[ii];
142
143 // expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}}
144 #pragma omp simd
145 for (ii = 0; ii < 10; ++jj)
146 c[ii] = a[jj];
147
148 // expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}}
149 #pragma omp simd
150 for (ii = 0; ii < 10; ++ ++ ii)
151 c[ii] = a[ii];
152
153 // Ok but undefined behavior (in general, cannot check that incr
154 // is really loop-invariant).
155 #pragma omp simd
156 for (ii = 0; ii < 10; ii = ii + ii)
157 c[ii] = a[ii];
158
159 // expected-error@+2 {{expression must have integral or unscoped enumeration type, not 'float'}}
160 #pragma omp simd
161 for (ii = 0; ii < 10; ii = ii + 1.0f)
162 c[ii] = a[ii];
163
164 // Ok - step was converted to integer type.
165 #pragma omp simd
166 for (ii = 0; ii < 10; ii = ii + (int)1.1f)
167 c[ii] = a[ii];
168
169 // expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}}
170 #pragma omp simd
171 for (ii = 0; ii < 10; jj = ii + 2)
172 c[ii] = a[ii];
173
174 // expected-warning@+3 {{relational comparison result unused}}
175 // expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}}
176 #pragma omp simd
177 for (ii = 0; ii < 10; jj > kk + 2)
178 c[ii] = a[ii];
179
180 // expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}}
181 #pragma omp simd
182 for (ii = 0; ii < 10;)
183 c[ii] = a[ii];
184
185 // expected-warning@+3 {{expression result unused}}
186 // expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}}
187 #pragma omp simd
188 for (ii = 0; ii < 10; !ii)
189 c[ii] = a[ii];
190
191 // expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}}
192 #pragma omp simd
193 for (ii = 0; ii < 10; ii ? ++ii : ++jj)
194 c[ii] = a[ii];
195
196 // expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'ii'}}
197 #pragma omp simd
198 for (ii = 0; ii < 10; ii = ii < 10)
199 c[ii] = a[ii];
200
201 // expected-note@+3 {{loop step is expected to be positive due to this condition}}
202 // expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}}
203 #pragma omp simd
204 for (ii = 0; ii < 10; ii = ii + 0)
205 c[ii] = a[ii];
206
207 // expected-note@+3 {{loop step is expected to be positive due to this condition}}
208 // expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}}
209 #pragma omp simd
210 for (ii = 0; ii < 10; ii = ii + (int)(0.8 - 0.45))
211 c[ii] = a[ii];
212
213 // expected-note@+3 {{loop step is expected to be positive due to this condition}}
214 // expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}}
215 #pragma omp simd
216 for (ii = 0; (ii) < 10; ii-=25)
217 c[ii] = a[ii];
218
219 // expected-note@+3 {{loop step is expected to be positive due to this condition}}
220 // expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}}
221 #pragma omp simd
222 for (ii = 0; (ii < 10); ii-=0)
223 c[ii] = a[ii];
224
225 // expected-note@+3 {{loop step is expected to be negative due to this condition}}
226 // expected-error@+2 {{increment expression must cause 'ii' to decrease on each iteration of OpenMP for loop}}
227 #pragma omp simd
228 for (ii = 0; ii > 10; (ii+=0))
229 c[ii] = a[ii];
230
231 // expected-note@+3 {{loop step is expected to be positive due to this condition}}
232 // expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}}
233 #pragma omp simd
234 for (ii = 0; ii < 10; (ii) = (1-1)+(ii))
235 c[ii] = a[ii];
236
237 // expected-note@+3 {{loop step is expected to be negative due to this condition}}
238 // expected-error@+2 {{increment expression must cause 'ii' to decrease on each iteration of OpenMP for loop}}
239 #pragma omp simd
240 for ((ii = 0); ii > 10; (ii-=0))
241 c[ii] = a[ii];
242
243 // expected-note@+3 {{loop step is expected to be positive due to this condition}}
244 // expected-error@+2 {{increment expression must cause 'ii' to increase on each iteration of OpenMP for loop}}
245 #pragma omp simd
246 for (ii = 0; (ii < 10); (ii-=0))
247 c[ii] = a[ii];
248
249 #ifndef OMP50
250 // expected-note@+3 {{defined as private}}
251 // expected-error@+3 {{loop iteration variable in the associated loop of 'omp simd' directive may not be private, predetermined as linear}}
252 #endif // OMP50
253 #pragma omp simd private(ii)
254 for (ii = 0; ii < 10; ii++)
255 c[ii] = a[ii];
256
257 #ifndef OMP50
258 // expected-note@+3 {{defined as lastprivate}}
259 // expected-error@+3 {{loop iteration variable in the associated loop of 'omp simd' directive may not be lastprivate, predetermined as linear}}
260 #endif // OMP50
261 #pragma omp simd lastprivate(ii)
262 for (ii = 0; ii < 10; ii++)
263 c[ii] = a[ii];
264
265 // expected-error@+1 {{unexpected OpenMP clause 'shared' in directive '#pragma omp simd'}}
266 #pragma omp simd shared(ii)
267 for (ii = 0; ii < 10; ii++)
268 c[ii] = a[ii];
269
270 #pragma omp simd linear(ii)
271 for (ii = 0; ii < 10; ii++)
272 c[ii] = a[ii];
273
274 #pragma omp simd lastprivate(ii) linear(jj) collapse(2) // expected-note {{defined as linear}}
275 for (ii = 0; ii < 10; ii++)
276 for (jj = 0; jj < 10; jj++) // expected-error {{loop iteration variable in the associated loop of 'omp simd' directive may not be linear, predetermined as lastprivate}}
277 c[ii] = a[jj];
278
279
280 #pragma omp parallel
281 {
282 // expected-error@+2 {{loop iteration variable in the associated loop of 'omp simd' directive may not be threadprivate or thread local, predetermined as linear}}
283 #pragma omp simd
284 for (sii = 0; sii < 10; sii+=1)
285 c[sii] = a[sii];
286 }
287
288 #pragma omp parallel
289 {
290 #pragma omp simd
291 for (globalii = 0; globalii < 10; globalii+=1)
292 c[globalii] = a[globalii];
293 }
294
295 #pragma omp parallel
296 {
297 #pragma omp simd collapse(2)
298 for (ii = 0; ii < 10; ii += 1)
299 for (globalii = 0; globalii < 10; globalii += 1)
300 c[globalii] += a[globalii] + ii;
301 }
302
303 // expected-error@+2 {{statement after '#pragma omp simd' must be a for loop}}
304 #pragma omp simd
305 for (auto &item : a) {
306 item = item + 1;
307 }
308
309 // expected-note@+3 {{loop step is expected to be positive due to this condition}}
310 // expected-error@+2 {{increment expression must cause 'i' to increase on each iteration of OpenMP for loop}}
311 #pragma omp simd
312 for (unsigned i = 9; i < 10; i--) {
313 c[i] = a[i] + b[i];
314 }
315
316 int (*lb)[4] = nullptr;
317 #pragma omp simd
318 for (int (*p)[4] = lb; p < lb + 8; ++p) {
319 }
320
321 // expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
322 #pragma omp simd
323 for (int a{0}; a<10; ++a) {
324 }
325
326 return 0;
327 }
328
329 // Iterators allowed in openmp for-loops.
330 namespace std {
331 struct random_access_iterator_tag { };
332 template <class Iter> struct iterator_traits {
333 typedef typename Iter::difference_type difference_type;
334 typedef typename Iter::iterator_category iterator_category;
335 };
336 template <class Iter>
337 typename iterator_traits<Iter>::difference_type
distance(Iter first,Iter last)338 distance(Iter first, Iter last) { return first - last; }
339 }
340 class Iter0 {
341 public:
Iter0()342 Iter0() { }
Iter0(const Iter0 &)343 Iter0(const Iter0 &) { }
operator ++()344 Iter0 operator ++() { return *this; }
operator --()345 Iter0 operator --() { return *this; }
operator +(int delta)346 Iter0 operator + (int delta) { return *this; }
operator <(Iter0 a)347 bool operator <(Iter0 a) { return true; }
348 };
349 // expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'Iter0' for 1st argument}}
operator -(Iter0 a,Iter0 b)350 int operator -(Iter0 a, Iter0 b) { return 0; }
351 class Iter1 {
352 public:
Iter1(float f=0.0f,double d=0.0)353 Iter1(float f=0.0f, double d=0.0) { }
Iter1(const Iter1 &)354 Iter1(const Iter1 &) { }
operator ++()355 Iter1 operator ++() { return *this; }
operator --()356 Iter1 operator --() { return *this; }
operator <(Iter1 a)357 bool operator <(Iter1 a) { return true; }
operator >=(Iter1 a)358 bool operator >=(Iter1 a) { return false; }
359 };
360 class GoodIter {
361 public:
GoodIter()362 GoodIter() { }
GoodIter(const GoodIter &)363 GoodIter(const GoodIter &) { }
GoodIter(int fst,int snd)364 GoodIter(int fst, int snd) { }
operator =(const GoodIter & that)365 GoodIter &operator =(const GoodIter &that) { return *this; }
operator =(const Iter0 & that)366 GoodIter &operator =(const Iter0 &that) { return *this; }
operator +=(int x)367 GoodIter &operator +=(int x) { return *this; }
GoodIter(void *)368 explicit GoodIter(void *) { }
operator ++()369 GoodIter operator ++() { return *this; }
operator --()370 GoodIter operator --() { return *this; }
operator !()371 bool operator !() { return true; }
operator <(GoodIter a)372 bool operator <(GoodIter a) { return true; }
operator <=(GoodIter a)373 bool operator <=(GoodIter a) { return true; }
operator >=(GoodIter a)374 bool operator >=(GoodIter a) { return false; }
375 typedef int difference_type;
376 typedef std::random_access_iterator_tag iterator_category;
377 };
378 // expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'GoodIter' for 1st argument}}
operator -(GoodIter a,GoodIter b)379 int operator -(GoodIter a, GoodIter b) { return 0; }
380 // expected-note@+1 2 {{candidate function not viable: requires single argument 'a', but 2 arguments were provided}}
operator -(GoodIter a)381 GoodIter operator -(GoodIter a) { return a; }
382 // expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'GoodIter' for 1st argument}}
operator -(GoodIter a,int v)383 GoodIter operator -(GoodIter a, int v) { return GoodIter(); }
operator +(GoodIter a,int v)384 GoodIter operator +(GoodIter a, int v) { return GoodIter(); }
385 // expected-note@+1 2 {{candidate function not viable: no known conversion from 'Iter1' to 'int' for 1st argument}}
operator -(int v,GoodIter a)386 GoodIter operator -(int v, GoodIter a) { return GoodIter(); }
operator +(int v,GoodIter a)387 GoodIter operator +(int v, GoodIter a) { return GoodIter(); }
388
test_with_random_access_iterator()389 int test_with_random_access_iterator() {
390 GoodIter begin, end;
391 Iter0 begin0, end0;
392 #pragma omp simd
393 for (GoodIter I = begin; I < end; ++I)
394 ++I;
395 // expected-error@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
396 #pragma omp simd
397 for (GoodIter &I = begin; I < end; ++I)
398 ++I;
399 #pragma omp simd
400 for (GoodIter I = begin; I >= end; --I)
401 ++I;
402 // expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
403 #pragma omp simd
404 for (GoodIter I(begin); I < end; ++I)
405 ++I;
406 // expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
407 #pragma omp simd
408 for (GoodIter I(nullptr); I < end; ++I)
409 ++I;
410 // expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
411 #pragma omp simd
412 for (GoodIter I(0); I < end; ++I)
413 ++I;
414 // expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
415 #pragma omp simd
416 for (GoodIter I(1,2); I < end; ++I)
417 ++I;
418 #pragma omp simd
419 for (begin = GoodIter(0); begin < end; ++begin)
420 ++begin;
421 #pragma omp simd
422 for (begin = GoodIter(1,2); begin < end; ++begin)
423 ++begin;
424 // expected-error@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
425 #pragma omp simd
426 for (++begin; begin < end; ++begin)
427 ++begin;
428 #pragma omp simd
429 for (begin = end; begin < end; ++begin)
430 ++begin;
431 // expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'I'}}
432 #pragma omp simd
433 for (GoodIter I = begin; I - I; ++I)
434 ++I;
435 // expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'I'}}
436 #pragma omp simd
437 for (GoodIter I = begin; begin < end; ++I)
438 ++I;
439 // expected-error@+2 {{condition of OpenMP for loop must be a relational comparison ('<', '<=', '>', or '>=') of loop variable 'I'}}
440 #pragma omp simd
441 for (GoodIter I = begin; !I; ++I)
442 ++I;
443 // expected-note@+3 {{loop step is expected to be negative due to this condition}}
444 // expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}}
445 #pragma omp simd
446 for (GoodIter I = begin; I >= end; I = I + 1)
447 ++I;
448 #pragma omp simd
449 for (GoodIter I = begin; I >= end; I = I - 1)
450 ++I;
451 // expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'I'}}
452 #pragma omp simd
453 for (GoodIter I = begin; I >= end; I = -I)
454 ++I;
455 // expected-note@+3 {{loop step is expected to be negative due to this condition}}
456 // expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}}
457 #pragma omp simd
458 for (GoodIter I = begin; I >= end; I = 2 + I)
459 ++I;
460 // expected-error@+2 {{increment clause of OpenMP for loop must perform simple addition or subtraction on loop variable 'I'}}
461 #pragma omp simd
462 for (GoodIter I = begin; I >= end; I = 2 - I)
463 ++I;
464 #pragma omp simd
465 for (Iter0 I = begin0; I < end0; ++I)
466 ++I;
467
468 // Initializer is constructor without params.
469 // expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
470 #pragma omp simd
471 for (Iter0 I; I < end0; ++I)
472 ++I;
473
474 Iter1 begin1, end1;
475 // expected-error@+3 {{invalid operands to binary expression ('Iter1' and 'Iter1')}}
476 // expected-error@+2 {{could not calculate number of iterations calling 'operator-' with upper and lower loop bounds}}
477 #pragma omp simd
478 for (Iter1 I = begin1; I < end1; ++I)
479 ++I;
480 // expected-note@+3 {{loop step is expected to be negative due to this condition}}
481 // expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}}
482 #pragma omp simd
483 for (Iter1 I = begin1; I >= end1; ++I)
484 ++I;
485
486 // Initializer is constructor with all default params.
487 // expected-error@+4 {{invalid operands to binary expression ('Iter1' and 'float')}}
488 // expected-error@+3 {{could not calculate number of iterations calling 'operator-' with upper and lower loop bounds}}
489 // expected-warning@+2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
490 #pragma omp simd
491 for (Iter1 I; I < end1; ++I) {
492 }
493
494 return 0;
495 }
496
497 template <typename IT, int ST> class TC {
498 public:
dotest_lt(IT begin,IT end)499 int dotest_lt(IT begin, IT end) {
500 // expected-note@+3 {{loop step is expected to be positive due to this condition}}
501 // expected-error@+2 {{increment expression must cause 'I' to increase on each iteration of OpenMP for loop}}
502 #pragma omp simd
503 for (IT I = begin; I < end; I = I + ST) {
504 ++I;
505 }
506 // expected-note@+3 {{loop step is expected to be positive due to this condition}}
507 // expected-error@+2 {{increment expression must cause 'I' to increase on each iteration of OpenMP for loop}}
508 #pragma omp simd
509 for (IT I = begin; I <= end; I += ST) {
510 ++I;
511 }
512 #pragma omp simd
513 for (IT I = begin; I < end; ++I) {
514 ++I;
515 }
516 }
517
step()518 static IT step() {
519 return IT(ST);
520 }
521 };
dotest_gt(IT begin,IT end)522 template <typename IT, int ST=0> int dotest_gt(IT begin, IT end) {
523 // expected-note@+3 2 {{loop step is expected to be negative due to this condition}}
524 // expected-error@+2 2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}}
525 #pragma omp simd
526 for (IT I = begin; I >= end; I = I + ST) {
527 ++I;
528 }
529 // expected-note@+3 2 {{loop step is expected to be negative due to this condition}}
530 // expected-error@+2 2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}}
531 #pragma omp simd
532 for (IT I = begin; I >= end; I += ST) {
533 ++I;
534 }
535
536 // expected-note@+3 {{loop step is expected to be negative due to this condition}}
537 // expected-error@+2 {{increment expression must cause 'I' to decrease on each iteration of OpenMP for loop}}
538 #pragma omp simd
539 for (IT I = begin; I >= end; ++I) {
540 ++I;
541 }
542
543 #pragma omp simd
544 for (IT I = begin; I < end; I+=TC<int,ST>::step()) {
545 ++I;
546 }
547 }
548
test_with_template()549 void test_with_template() {
550 GoodIter begin, end;
551 TC<GoodIter, 100> t1;
552 TC<GoodIter, -100> t2;
553 t1.dotest_lt(begin, end);
554 t2.dotest_lt(begin, end); // expected-note {{in instantiation of member function 'TC<GoodIter, -100>::dotest_lt' requested here}}
555 dotest_gt(begin, end); // expected-note {{in instantiation of function template specialization 'dotest_gt<GoodIter, 0>' requested here}}
556 dotest_gt<unsigned, 10>(0, 100); // expected-note {{in instantiation of function template specialization 'dotest_gt<unsigned int, 10>' requested here}}
557 }
558
test_loop_break()559 void test_loop_break() {
560 const int N = 100;
561 float a[N], b[N], c[N];
562 #pragma omp simd
563 for (int i = 0; i < 10; i++) {
564 c[i] = a[i] + b[i];
565 for (int j = 0; j < 10; ++j) {
566 if (a[i] > b[j])
567 break; // OK in nested loop
568 }
569 switch(i) {
570 case 1:
571 b[i]++;
572 break;
573 default:
574 break;
575 }
576 if (c[i] > 10)
577 break; // expected-error {{'break' statement cannot be used in OpenMP for loop}}
578
579 if (c[i] > 11)
580 break; // expected-error {{'break' statement cannot be used in OpenMP for loop}}
581 }
582
583 #pragma omp simd
584 for (int i = 0; i < 10; i++) {
585 for (int j = 0; j < 10; j++) {
586 c[i] = a[i] + b[i];
587 if (c[i] > 10) {
588 if (c[i] < 20) {
589 break; // OK
590 }
591 }
592 }
593 }
594 }
595
test_loop_eh()596 void test_loop_eh() {
597 const int N = 100;
598 float a[N], b[N], c[N];
599 #pragma omp simd
600 for (int i = 0; i < 10; i++) {
601 c[i] = a[i] + b[i];
602 try { // expected-error {{'try' statement cannot be used in OpenMP simd region}}
603 for (int j = 0; j < 10; ++j) {
604 if (a[i] > b[j])
605 throw a[i]; // expected-error {{'throw' statement cannot be used in OpenMP simd region}}
606 }
607 throw a[i]; // expected-error {{'throw' statement cannot be used in OpenMP simd region}}
608 }
609 catch (float f) {
610 if (f > 0.1)
611 throw a[i]; // expected-error {{'throw' statement cannot be used in OpenMP simd region}}
612 return; // expected-error {{cannot return from OpenMP region}}
613 }
614 switch(i) {
615 case 1:
616 b[i]++;
617 break;
618 default:
619 break;
620 }
621 for (int j = 0; j < 10; j++) {
622 if (c[i] > 10)
623 throw c[i]; // expected-error {{'throw' statement cannot be used in OpenMP simd region}}
624 }
625 }
626 if (c[9] > 10)
627 throw c[9]; // OK
628
629 #pragma omp simd
630 for (int i = 0; i < 10; ++i) {
631 struct S {
632 void g() { throw 0; }
633 };
634 }
635 }
636
637