clang/test/OpenMP/simd_loop_messages.cpp

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