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