gcc/testsuite/c-c++-common/gomp/pr63326.c

   1 /* PR c/63326 */
   2 /* { dg-do compile } */
   3 /* { dg-options "-fopenmp" } */
   4
   5 void
   6 f1 (int x)
   7 {
   8   int i;
   9   if (x)
  10     #pragma omp barrier                         /* { dg-error "may only be used in compound statements" } */
  11   ;
  12   if (x)
  13     #pragma omp flush                           /* { dg-error "may only be used in compound statements" } */
  14   ;
  15   if (x)
  16     #pragma omp taskwait                        /* { dg-error "may only be used in compound statements" } */
  17   ;
  18   if (x)
  19     #pragma omp taskyield                       /* { dg-error "may only be used in compound statements" } */
  20   ;
  21   #pragma omp parallel
  22   {
  23     if (x)
  24       #pragma omp cancel parallel               /* { dg-error "may only be used in compound statements" } */
  25     ;
  26   }
  27   #pragma omp parallel
  28   {
  29     if (x)
  30       #pragma omp cancellation point parallel   /* { dg-error "may only be used in compound statements" } */
  31     ;
  32   }
  33   #pragma omp for ordered(1)
  34   for (i = 0; i < 16; i++)
  35     {
  36       if (x)
  37         #pragma omp ordered depend(source)      /* { dg-error "may only be used in compound statements" } */
  38       ;
  39       if (x)
  40         #pragma omp ordered depend(sink: i-1)   /* { dg-error "may only be used in compound statements" } */
  41       ;
  42     }
  43   if (x)
  44     #pragma omp target enter data map(to:i)     /* { dg-error "may only be used in compound statements" } */
  45   ;
  46   if (x)
  47     #pragma omp target update to(i)             /* { dg-error "may only be used in compound statements" } */
  48   ;
  49   if (x)
  50     #pragma omp target exit data map(from:i)    /* { dg-error "may only be used in compound statements" } */
  51   ;
  52 }
  53
  54 void
  55 f2 (int x)
  56 {
  57   int i;
  58   while (x)
  59     #pragma omp barrier                         /* { dg-error "may only be used in compound statements" } */
  60   ;
  61   while (x)
  62     #pragma omp flush                           /* { dg-error "may only be used in compound statements" } */
  63   ;
  64   while (x)
  65     #pragma omp taskwait                        /* { dg-error "may only be used in compound statements" } */
  66   ;
  67   while (x)
  68     #pragma omp taskyield                       /* { dg-error "may only be used in compound statements" } */
  69   ;
  70   #pragma omp parallel
  71   {
  72     while (x)
  73       #pragma omp cancel parallel               /* { dg-error "may only be used in compound statements" } */
  74     ;
  75   }
  76   #pragma omp parallel
  77   {
  78     while (x)
  79       #pragma omp cancellation point parallel   /* { dg-error "may only be used in compound statements" } */
  80     ;
  81   }
  82   #pragma omp for ordered(1)
  83   for (i = 0; i < 16; i++)
  84     {
  85       while (x)
  86         #pragma omp ordered depend(source)      /* { dg-error "may only be used in compound statements" } */
  87       ;
  88       while (x)
  89         #pragma omp ordered depend(sink: i-1)   /* { dg-error "may only be used in compound statements" } */
  90       ;
  91     }
  92   while (x)
  93     #pragma omp target enter data map(to:i)     /* { dg-error "may only be used in compound statements" } */
  94   ;
  95   while (x)
  96     #pragma omp target update to(i)             /* { dg-error "may only be used in compound statements" } */
  97   ;
  98   while (x)
  99     #pragma omp target exit data map(from:i)    /* { dg-error "may only be used in compound statements" } */
 100   ;
 101 }
 102
 103 void
 104 f3 (int x)
 105 {
 106   int i;
 107   for (x = 0; x < 10; x++)
 108     #pragma omp barrier                         /* { dg-error "may only be used in compound statements" } */
 109   ;
 110   for (x = 0; x < 10; x++)
 111     #pragma omp flush                           /* { dg-error "may only be used in compound statements" } */
 112   ;
 113   for (x = 0; x < 10; x++)
 114     #pragma omp taskwait                        /* { dg-error "may only be used in compound statements" } */
 115   ;
 116   for (x = 0; x < 10; x++)
 117     #pragma omp taskyield                       /* { dg-error "may only be used in compound statements" } */
 118   ;
 119   #pragma omp parallel
 120   {
 121     for (x = 0; x < 10; x++)
 122       #pragma omp cancel parallel               /* { dg-error "may only be used in compound statements" } */
 123     ;
 124   }
 125   #pragma omp parallel
 126   {
 127     for (x = 0; x < 10; x++)
 128       #pragma omp cancellation point parallel   /* { dg-error "may only be used in compound statements" } */
 129     ;
 130   }
 131   #pragma omp for ordered(1)
 132   for (i = 0; i < 16; i++)
 133     {
 134       for (x = 0; x < 10; x++)
 135         #pragma omp ordered depend(source)      /* { dg-error "may only be used in compound statements" } */
 136       ;
 137       for (x = 0; x < 10; x++)
 138         #pragma omp ordered depend(sink: i-1)   /* { dg-error "may only be used in compound statements" } */
 139       ;
 140     }
 141   for (x = 0; x < 10; x++)
 142     #pragma omp target enter data map(to:i)     /* { dg-error "may only be used in compound statements" } */
 143   ;
 144   for (x = 0; x < 10; x++)
 145     #pragma omp target update to(i)             /* { dg-error "may only be used in compound statements" } */
 146   ;
 147   for (x = 0; x < 10; x++)
 148     #pragma omp target exit data map(from:i)    /* { dg-error "may only be used in compound statements" } */
 149   ;
 150 }
 151
 152 void
 153 f4 (int x)
 154 {
 155   int i;
 156   {
 157     do
 158       #pragma omp barrier                       /* { dg-error "may only be used in compound statements" } */
 159     while (0);
 160   }
 161   {
 162     do
 163       #pragma omp flush                         /* { dg-error "may only be used in compound statements" } */
 164     while (0);
 165   }
 166   {
 167     do
 168       #pragma omp taskwait                      /* { dg-error "may only be used in compound statements" } */
 169     while (0);
 170   }
 171   {
 172     do
 173       #pragma omp taskyield                     /* { dg-error "may only be used in compound statements" } */
 174     while (0);
 175   }
 176   #pragma omp parallel
 177   {
 178     do
 179       #pragma omp cancel parallel               /* { dg-error "may only be used in compound statements" } */
 180     while (0);
 181   }
 182   #pragma omp parallel
 183   {
 184     do
 185       #pragma omp cancellation point parallel   /* { dg-error "may only be used in compound statements" } */
 186     while (0);
 187   }
 188   #pragma omp for ordered(1)
 189   for (i = 0; i < 16; i++)
 190     {
 191       {
 192         do
 193           #pragma omp ordered depend(source)    /* { dg-error "may only be used in compound statements" } */
 194         while (0);
 195       }
 196       {
 197         do
 198           #pragma omp ordered depend(sink: i-1) /* { dg-error "may only be used in compound statements" } */
 199         while (0);
 200       }
 201     }
 202   {
 203     do
 204       #pragma omp target enter data map(to:i)   /* { dg-error "may only be used in compound statements" } */
 205     while (0);
 206   }
 207   {
 208     do
 209       #pragma omp target update to(i)           /* { dg-error "may only be used in compound statements" } */
 210     while (0);
 211   }
 212   {
 213     do
 214       #pragma omp target exit data map(from:i)  /* { dg-error "may only be used in compound statements" } */
 215     while (0);
 216   }
 217 }
 218
 219 void
 220 f5 (int x)
 221 {
 222   int i;
 223   switch (x)
 224     #pragma omp barrier                         /* { dg-error "may only be used in compound statements" } */
 225   ;
 226   switch (x)
 227     #pragma omp flush                           /* { dg-error "may only be used in compound statements" } */
 228   ;
 229   switch (x)
 230     #pragma omp taskwait                        /* { dg-error "may only be used in compound statements" } */
 231   ;
 232   switch (x)
 233     #pragma omp taskyield                       /* { dg-error "may only be used in compound statements" } */
 234   ;
 235   #pragma omp parallel
 236   {
 237     switch (x)
 238       #pragma omp cancel parallel               /* { dg-error "may only be used in compound statements" } */
 239     ;
 240   }
 241   #pragma omp parallel
 242   {
 243     switch (x)
 244       #pragma omp cancellation point parallel   /* { dg-error "may only be used in compound statements" } */
 245     ;
 246   }
 247   #pragma omp for ordered(1)
 248   for (i = 0; i < 16; i++)
 249     {
 250       switch (x)
 251         #pragma omp ordered depend(source)      /* { dg-error "may only be used in compound statements" } */
 252       ;
 253       switch (x)
 254         #pragma omp ordered depend(sink: i-1)   /* { dg-error "may only be used in compound statements" } */
 255       ;
 256     }
 257   switch (x)
 258     #pragma omp target enter data map(to:i)     /* { dg-error "may only be used in compound statements" } */
 259   ;
 260   switch (x)
 261     #pragma omp target update to(i)             /* { dg-error "may only be used in compound statements" } */
 262   ;
 263   switch (x)
 264     #pragma omp target exit data map(from:i)    /* { dg-error "may only be used in compound statements" } */
 265   ;
 266 }
 267
 268 void
 269 f6 (int x)
 270 {
 271   int i;
 272   switch (x)
 273     {
 274     case 1:
 275       #pragma omp barrier                       /* { dg-error "may only be used in compound statements" } */
 276       ;
 277     }
 278   switch (x)
 279     {
 280     case 1:
 281       #pragma omp flush                         /* { dg-error "may only be used in compound statements" } */
 282       ;
 283     }
 284   switch (x)
 285     {
 286     case 1:
 287       #pragma omp taskwait                      /* { dg-error "may only be used in compound statements" } */
 288       ;
 289     }
 290   switch (x)
 291     {
 292     case 1:
 293       #pragma omp taskyield                     /* { dg-error "may only be used in compound statements" } */
 294       ;
 295     }
 296   #pragma omp parallel
 297   {
 298     switch (x)
 299       {
 300       case 1:
 301         #pragma omp cancel parallel             /* { dg-error "may only be used in compound statements" } */
 302         ;
 303       }
 304   }
 305   #pragma omp parallel
 306   {
 307     switch (x)
 308       {
 309       case 1:
 310         #pragma omp cancellation point parallel /* { dg-error "may only be used in compound statements" } */
 311         ;
 312       }
 313   }
 314   #pragma omp for ordered(1)
 315   for (i = 0; i < 16; i++)
 316     {
 317       switch (x)
 318         {
 319         case 1:
 320           #pragma omp ordered depend(source)    /* { dg-error "may only be used in compound statements" } */
 321           ;
 322         }
 323       switch (x)
 324         {
 325         case 1:
 326           #pragma omp ordered depend(sink: i-1) /* { dg-error "may only be used in compound statements" } */
 327           ;
 328         }
 329     }
 330   switch (x)
 331     {
 332     case 1:
 333       #pragma omp target enter data map(to:i)   /* { dg-error "may only be used in compound statements" } */
 334       ;
 335     }
 336   switch (x)
 337     {
 338     case 1:
 339       #pragma omp target update to(i)           /* { dg-error "may only be used in compound statements" } */
 340       ;
 341     }
 342   switch (x)
 343     {
 344     case 1:
 345       #pragma omp target exit data map(from:i)  /* { dg-error "may only be used in compound statements" } */
 346       ;
 347     }
 348 }
 349
 350 void
 351 f7 (int x)
 352 {
 353   int i;
 354   switch (x)
 355     {
 356     default:
 357       #pragma omp barrier                       /* { dg-error "may only be used in compound statements" } */
 358       ;
 359     }
 360   switch (x)
 361     {
 362     default:
 363       #pragma omp flush                         /* { dg-error "may only be used in compound statements" } */
 364       ;
 365     }
 366   switch (x)
 367     {
 368     default:
 369       #pragma omp taskwait                      /* { dg-error "may only be used in compound statements" } */
 370       ;
 371     }
 372   switch (x)
 373     {
 374     default:
 375       #pragma omp taskyield                     /* { dg-error "may only be used in compound statements" } */
 376       ;
 377     }
 378   #pragma omp parallel
 379   {
 380     switch (x)
 381       {
 382       default:
 383         #pragma omp cancel parallel             /* { dg-error "may only be used in compound statements" } */
 384         ;
 385       }
 386   }
 387   #pragma omp parallel
 388   {
 389     switch (x)
 390       {
 391       default:
 392         #pragma omp cancellation point parallel /* { dg-error "may only be used in compound statements" } */
 393         ;
 394       }
 395   }
 396   #pragma omp for ordered(1)
 397   for (i = 0; i < 16; i++)
 398     {
 399       switch (x)
 400         {
 401         default:
 402           #pragma omp ordered depend(source)    /* { dg-error "may only be used in compound statements" } */
 403           ;
 404         }
 405       switch (x)
 406         {
 407         default:
 408           #pragma omp ordered depend(sink: i-1) /* { dg-error "may only be used in compound statements" } */
 409           ;
 410         }
 411     }
 412   switch (x)
 413     {
 414     default:
 415       #pragma omp target enter data map(to:i)   /* { dg-error "may only be used in compound statements" } */
 416       ;
 417     }
 418   switch (x)
 419     {
 420     default:
 421       #pragma omp target update to(i)           /* { dg-error "may only be used in compound statements" } */
 422       ;
 423     }
 424   switch (x)
 425     {
 426     default:
 427       #pragma omp target exit data map(from:i)  /* { dg-error "may only be used in compound statements" } */
 428       ;
 429     }
 430 }
 431
 432 void
 433 f8 (int x)
 434 {
 435   int i;
 436   lab1:
 437     #pragma omp barrier                         /* { dg-error "may only be used in compound statements" } */
 438   ;
 439   lab2:
 440     #pragma omp flush                           /* { dg-error "may only be used in compound statements" } */
 441   ;
 442   lab3:
 443     #pragma omp taskwait                        /* { dg-error "may only be used in compound statements" } */
 444   ;
 445   lab4:
 446     #pragma omp taskyield                       /* { dg-error "may only be used in compound statements" } */
 447   ;
 448   #pragma omp parallel
 449   {
 450     lab5:
 451       #pragma omp cancel parallel               /* { dg-error "may only be used in compound statements" } */
 452     ;
 453   }
 454   #pragma omp parallel
 455   {
 456     lab6:
 457       #pragma omp cancellation point parallel   /* { dg-error "may only be used in compound statements" } */
 458     ;
 459   }
 460   #pragma omp for ordered(1)
 461   for (i = 0; i < 16; i++)
 462     {
 463       lab7:
 464         #pragma omp ordered depend(source)      /* { dg-error "may only be used in compound statements" } */
 465       ;
 466       lab8:
 467         #pragma omp ordered depend(sink: i-1)   /* { dg-error "may only be used in compound statements" } */
 468       ;
 469     }
 470   lab9:
 471     #pragma omp target enter data map(to:i)     /* { dg-error "may only be used in compound statements" } */
 472   ;
 473   lab10:
 474     #pragma omp target update to(i)             /* { dg-error "may only be used in compound statements" } */
 475   ;
 476   lab11:
 477     #pragma omp target exit data map(from:i)    /* { dg-error "may only be used in compound statements" } */
 478   ;
 479 }