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