test/OpenMP/simd_loop_messages.cpp

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