xref: /minix3/external/bsd/llvm/dist/clang/test/OpenMP/nesting_of_regions.cpp (revision 340f5e56603e4275faeb89a9aacace41ba22d661) 
1 // RUN: %clang_cc1 -fsyntax-only -fopenmp=libiomp5 -verify %s
2 
3 void bar();
4 
5 template <class T>
6 void foo() {
7   T a = T();
8 // PARALLEL DIRECTIVE
9 #pragma omp parallel
10 #pragma omp for
11   for (int i = 0; i < 10; ++i)
12     ;
13 #pragma omp parallel
14 #pragma omp simd
15   for (int i = 0; i < 10; ++i)
16     ;
17 #pragma omp parallel
18 #pragma omp for simd
19   for (int i = 0; i < 10; ++i)
20     ;
21 #pragma omp parallel
22 #pragma omp sections
23   {
24     bar();
25   }
26 #pragma omp parallel
27 #pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a parallel region}}
28   {
29     bar();
30   }
31 #pragma omp parallel
32 #pragma omp single
33   bar();
34 
35 #pragma omp parallel
36 #pragma omp master
37   {
38     bar();
39   }
40 #pragma omp parallel
41 #pragma omp critical
42   {
43     bar();
44   }
45 #pragma omp parallel
46 #pragma omp parallel for
47   for (int i = 0; i < 10; ++i)
48     ;
49 #pragma omp parallel
50 #pragma omp parallel for simd
51   for (int i = 0; i < 10; ++i)
52     ;
53 #pragma omp parallel
54 #pragma omp parallel sections
55   {
56     bar();
57   }
58 #pragma omp parallel
59 #pragma omp task
60   {
61     bar();
62   }
63 #pragma omp parallel
64   {
65 #pragma omp taskyield
66     bar();
67   }
68 #pragma omp parallel
69   {
70 #pragma omp barrier
71     bar();
72   }
73 #pragma omp parallel
74   {
75 #pragma omp taskwait
76     bar();
77   }
78 #pragma omp parallel
79   {
80 #pragma omp flush
81     bar();
82   }
83 #pragma omp parallel
84   {
85 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'parallel' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
86     bar();
87   }
88 #pragma omp parallel
89   {
90 #pragma omp atomic
91     ++a;
92   }
93 #pragma omp parallel
94   {
95 #pragma omp target
96     ++a;
97   }
98 #pragma omp parallel
99   {
100 #pragma omp teams // expected-error {{region cannot be closely nested inside 'parallel' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
101     ++a;
102   }
103 
104 // SIMD DIRECTIVE
105 #pragma omp simd
106   for (int i = 0; i < 10; ++i) {
107 #pragma omp for // expected-error {{OpenMP constructs may not be nested inside a simd region}}
108     for (int i = 0; i < 10; ++i)
109       ;
110   }
111 #pragma omp simd
112   for (int i = 0; i < 10; ++i) {
113 #pragma omp simd // expected-error {{OpenMP constructs may not be nested inside a simd region}}
114     for (int i = 0; i < 10; ++i)
115       ;
116   }
117 #pragma omp simd
118   for (int i = 0; i < 10; ++i) {
119 #pragma omp for simd // expected-error {{OpenMP constructs may not be nested inside a simd region}}
120     for (int i = 0; i < 10; ++i)
121       ;
122   }
123 #pragma omp simd
124   for (int i = 0; i < 10; ++i) {
125 #pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}}
126     for (int i = 0; i < 10; ++i)
127       ;
128   }
129 #pragma omp simd
130   for (int i = 0; i < 10; ++i) {
131 #pragma omp sections // expected-error {{OpenMP constructs may not be nested inside a simd region}}
132     {
133       bar();
134     }
135   }
136 #pragma omp simd
137   for (int i = 0; i < 10; ++i) {
138 #pragma omp section // expected-error {{OpenMP constructs may not be nested inside a simd region}}
139     {
140       bar();
141     }
142   }
143 #pragma omp simd
144   for (int i = 0; i < 10; ++i) {
145 #pragma omp single // expected-error {{OpenMP constructs may not be nested inside a simd region}}
146     {
147       bar();
148     }
149   }
150 #pragma omp simd
151   for (int i = 0; i < 10; ++i) {
152 #pragma omp master // expected-error {{OpenMP constructs may not be nested inside a simd region}}
153     {
154       bar();
155     }
156   }
157 #pragma omp simd
158   for (int i = 0; i < 10; ++i) {
159 #pragma omp critical // expected-error {{OpenMP constructs may not be nested inside a simd region}}
160     {
161       bar();
162     }
163   }
164 #pragma omp simd
165   for (int i = 0; i < 10; ++i) {
166 #pragma omp parallel for // expected-error {{OpenMP constructs may not be nested inside a simd region}}
167     for (int i = 0; i < 10; ++i)
168       ;
169   }
170 #pragma omp simd
171   for (int i = 0; i < 10; ++i) {
172 #pragma omp parallel for simd // expected-error {{OpenMP constructs may not be nested inside a simd region}}
173     for (int i = 0; i < 10; ++i)
174       ;
175   }
176 #pragma omp simd
177   for (int i = 0; i < 10; ++i) {
178 #pragma omp parallel sections // expected-error {{OpenMP constructs may not be nested inside a simd region}}
179     {
180       bar();
181     }
182   }
183 #pragma omp simd
184   for (int i = 0; i < 10; ++i) {
185 #pragma omp task // expected-error {{OpenMP constructs may not be nested inside a simd region}}
186     {
187       bar();
188     }
189   }
190 #pragma omp simd
191   for (int i = 0; i < 10; ++i) {
192 #pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}}
193     bar();
194   }
195 #pragma omp simd
196   for (int i = 0; i < 10; ++i) {
197 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
198     bar();
199   }
200 #pragma omp simd
201   for (int i = 0; i < 10; ++i) {
202 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
203     bar();
204   }
205 #pragma omp simd
206   for (int i = 0; i < 10; ++i) {
207 #pragma omp flush // expected-error {{OpenMP constructs may not be nested inside a simd region}}
208     bar();
209   }
210 #pragma omp simd
211   for (int i = 0; i < 10; ++i) {
212 #pragma omp ordered // expected-error {{OpenMP constructs may not be nested inside a simd region}}
213     bar();
214   }
215 #pragma omp simd
216   for (int i = 0; i < 10; ++i) {
217 #pragma omp atomic // expected-error {{OpenMP constructs may not be nested inside a simd region}}
218     ++a;
219   }
220 #pragma omp simd
221   for (int i = 0; i < 10; ++i) {
222 #pragma omp target // expected-error {{OpenMP constructs may not be nested inside a simd region}}
223     ++a;
224   }
225 #pragma omp simd
226   for (int i = 0; i < 10; ++i) {
227 #pragma omp teams // expected-error {{OpenMP constructs may not be nested inside a simd region}}
228     ++a;
229   }
230 
231 // FOR DIRECTIVE
232 #pragma omp for
233   for (int i = 0; i < 10; ++i) {
234 #pragma omp for // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
235     for (int i = 0; i < 10; ++i)
236       ;
237   }
238 #pragma omp for
239   for (int i = 0; i < 10; ++i) {
240 #pragma omp simd
241     for (int i = 0; i < 10; ++i)
242       ;
243   }
244 #pragma omp for
245   for (int i = 0; i < 10; ++i) {
246 #pragma omp for simd // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}}
247     for (int i = 0; i < 10; ++i)
248       ;
249   }
250 #pragma omp for
251   for (int i = 0; i < 10; ++i) {
252 #pragma omp parallel
253     for (int i = 0; i < 10; ++i)
254       ;
255   }
256 #pragma omp for
257   for (int i = 0; i < 10; ++i) {
258 #pragma omp sections // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
259     {
260       bar();
261     }
262   }
263 #pragma omp for
264   for (int i = 0; i < 10; ++i) {
265 #pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a for region}}
266     {
267       bar();
268     }
269   }
270 #pragma omp for
271   for (int i = 0; i < 10; ++i) {
272 #pragma omp single // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
273     {
274       bar();
275     }
276   }
277 
278 #pragma omp for
279   for (int i = 0; i < 10; ++i) {
280 #pragma omp master // expected-error {{region cannot be closely nested inside 'for' region}}
281     {
282       bar();
283     }
284   }
285 #pragma omp for
286   for (int i = 0; i < 10; ++i) {
287 #pragma omp critical
288     {
289       bar();
290     }
291   }
292 #pragma omp for
293   for (int i = 0; i < 10; ++i) {
294 #pragma omp parallel
295     {
296 #pragma omp single // OK
297       {
298         bar();
299       }
300 #pragma omp for // OK
301       for (int i = 0; i < 10; ++i)
302         ;
303 #pragma omp sections // OK
304       {
305         bar();
306       }
307     }
308   }
309 #pragma omp for
310   for (int i = 0; i < 10; ++i) {
311 #pragma omp parallel for
312     for (int i = 0; i < 10; ++i)
313       ;
314   }
315 #pragma omp for
316   for (int i = 0; i < 10; ++i) {
317 #pragma omp parallel for simd
318     for (int i = 0; i < 10; ++i)
319       ;
320   }
321 #pragma omp for
322   for (int i = 0; i < 10; ++i) {
323 #pragma omp parallel sections
324     {
325       bar();
326     }
327   }
328 #pragma omp for
329   for (int i = 0; i < 10; ++i) {
330 #pragma omp task
331     {
332       bar();
333     }
334   }
335 #pragma omp for
336   for (int i = 0; i < 10; ++i) {
337 #pragma omp taskyield
338     bar();
339   }
340 #pragma omp for
341   for (int i = 0; i < 10; ++i) {
342 #pragma omp barrier // expected-error {{region cannot be closely nested inside 'for' region}}
343     bar();
344   }
345 #pragma omp for
346   for (int i = 0; i < 10; ++i) {
347 #pragma omp taskwait
348     bar();
349   }
350 #pragma omp for
351   for (int i = 0; i < 10; ++i) {
352 #pragma omp flush
353     bar();
354   }
355 #pragma omp for
356   for (int i = 0; i < 10; ++i) {
357 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
358     bar();
359   }
360 #pragma omp for ordered
361   for (int i = 0; i < 10; ++i) {
362 #pragma omp ordered // OK
363     bar();
364   }
365 #pragma omp for
366   for (int i = 0; i < 10; ++i) {
367 #pragma omp atomic
368     ++a;
369   }
370 #pragma omp for
371   for (int i = 0; i < 10; ++i) {
372 #pragma omp target
373     ++a;
374   }
375 #pragma omp for
376   for (int i = 0; i < 10; ++i) {
377 #pragma omp teams // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
378     ++a;
379   }
380 
381 // FOR SIMD DIRECTIVE
382 #pragma omp for simd
383   for (int i = 0; i < 10; ++i) {
384 #pragma omp for // expected-error {{OpenMP constructs may not be nested inside a simd region}}
385     for (int i = 0; i < 10; ++i)
386       ;
387   }
388 #pragma omp for simd
389   for (int i = 0; i < 10; ++i) {
390 #pragma omp simd // expected-error {{OpenMP constructs may not be nested inside a simd region}}
391     for (int i = 0; i < 10; ++i)
392       ;
393   }
394 #pragma omp for simd
395   for (int i = 0; i < 10; ++i) {
396 #pragma omp for simd // expected-error {{OpenMP constructs may not be nested inside a simd region}}
397     for (int i = 0; i < 10; ++i)
398       ;
399   }
400 #pragma omp for simd
401   for (int i = 0; i < 10; ++i) {
402 #pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}}
403     for (int i = 0; i < 10; ++i)
404       ;
405   }
406 #pragma omp for simd
407   for (int i = 0; i < 10; ++i) {
408 #pragma omp sections // expected-error {{OpenMP constructs may not be nested inside a simd region}}
409     {
410       bar();
411     }
412   }
413 #pragma omp for simd
414   for (int i = 0; i < 10; ++i) {
415 #pragma omp section // expected-error {{OpenMP constructs may not be nested inside a simd region}}
416     {
417       bar();
418     }
419   }
420 #pragma omp for simd
421   for (int i = 0; i < 10; ++i) {
422 #pragma omp single // expected-error {{OpenMP constructs may not be nested inside a simd region}}
423     {
424       bar();
425     }
426   }
427 #pragma omp for simd
428   for (int i = 0; i < 10; ++i) {
429 #pragma omp master // expected-error {{OpenMP constructs may not be nested inside a simd region}}
430     {
431       bar();
432     }
433   }
434 #pragma omp for simd
435   for (int i = 0; i < 10; ++i) {
436 #pragma omp critical // expected-error {{OpenMP constructs may not be nested inside a simd region}}
437     {
438       bar();
439     }
440   }
441 #pragma omp for simd
442   for (int i = 0; i < 10; ++i) {
443 #pragma omp parallel for // expected-error {{OpenMP constructs may not be nested inside a simd region}}
444     for (int i = 0; i < 10; ++i)
445       ;
446   }
447 #pragma omp for simd
448   for (int i = 0; i < 10; ++i) {
449 #pragma omp parallel for simd // expected-error {{OpenMP constructs may not be nested inside a simd region}}
450     for (int i = 0; i < 10; ++i)
451       ;
452   }
453 #pragma omp for simd
454   for (int i = 0; i < 10; ++i) {
455 #pragma omp parallel sections // expected-error {{OpenMP constructs may not be nested inside a simd region}}
456     {
457       bar();
458     }
459   }
460 #pragma omp for simd
461   for (int i = 0; i < 10; ++i) {
462 #pragma omp task // expected-error {{OpenMP constructs may not be nested inside a simd region}}
463     {
464       bar();
465     }
466   }
467 #pragma omp for simd
468   for (int i = 0; i < 10; ++i) {
469 #pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}}
470     bar();
471   }
472 #pragma omp for simd
473   for (int i = 0; i < 10; ++i) {
474 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
475     bar();
476   }
477 #pragma omp for simd
478   for (int i = 0; i < 10; ++i) {
479 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
480     bar();
481   }
482 #pragma omp for simd
483   for (int i = 0; i < 10; ++i) {
484 #pragma omp flush // expected-error {{OpenMP constructs may not be nested inside a simd region}}
485     bar();
486   }
487 #pragma omp for simd
488   for (int i = 0; i < 10; ++i) {
489 #pragma omp ordered // expected-error {{OpenMP constructs may not be nested inside a simd region}}
490     bar();
491   }
492 #pragma omp for simd
493   for (int i = 0; i < 10; ++i) {
494 #pragma omp atomic // expected-error {{OpenMP constructs may not be nested inside a simd region}}
495     ++a;
496   }
497 #pragma omp for simd
498   for (int i = 0; i < 10; ++i) {
499 #pragma omp target // expected-error {{OpenMP constructs may not be nested inside a simd region}}
500     ++a;
501   }
502 #pragma omp for simd
503   for (int i = 0; i < 10; ++i) {
504 #pragma omp teams // expected-error {{OpenMP constructs may not be nested inside a simd region}}
505     ++a;
506   }
507 
508 // SECTIONS DIRECTIVE
509 #pragma omp sections
510   {
511 #pragma omp for // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
512     for (int i = 0; i < 10; ++i)
513       ;
514   }
515 #pragma omp sections
516   {
517 #pragma omp simd
518     for (int i = 0; i < 10; ++i)
519       ;
520   }
521 #pragma omp sections
522   {
523 #pragma omp for simd // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}}
524     for (int i = 0; i < 10; ++i)
525       ;
526   }
527 #pragma omp sections
528   {
529 #pragma omp parallel
530     for (int i = 0; i < 10; ++i)
531       ;
532   }
533 #pragma omp sections
534   {
535 #pragma omp sections // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
536     {
537       bar();
538     }
539   }
540 #pragma omp sections
541   {
542 #pragma omp section
543     {
544       bar();
545     }
546   }
547 #pragma omp sections
548   {
549 #pragma omp parallel
550     {
551 #pragma omp single // OK
552       {
553         bar();
554       }
555 #pragma omp for // OK
556       for (int i = 0; i < 10; ++i)
557         ;
558 #pragma omp sections // OK
559       {
560         bar();
561       }
562     }
563   }
564 #pragma omp sections
565   {
566 #pragma omp parallel
567     {
568 #pragma omp master // OK
569       {
570         bar();
571       }
572 #pragma omp for // OK
573       for (int i = 0; i < 10; ++i)
574         ;
575 #pragma omp master // OK
576       {
577         bar();
578       }
579     }
580 #pragma omp master // expected-error {{region cannot be closely nested inside 'sections' region}}
581     bar();
582   }
583 #pragma omp sections
584   {
585 #pragma omp parallel
586     {
587 #pragma omp critical(A) // OK
588       {
589         bar();
590       }
591 #pragma omp for // OK
592       for (int i = 0; i < 10; ++i)
593         ;
594 #pragma omp critical // OK
595       {
596         bar();
597       }
598     }
599 #pragma omp critical(A) // expected-error {{statement in 'omp sections' directive must be enclosed into a section region}}
600     bar();
601   }
602 #pragma omp sections
603   {
604 #pragma omp parallel for
605     for (int i = 0; i < 10; ++i)
606       ;
607   }
608 #pragma omp sections
609   {
610 #pragma omp parallel for simd
611     for (int i = 0; i < 10; ++i)
612       ;
613   }
614 #pragma omp sections
615   {
616 #pragma omp parallel sections
617     {
618       bar();
619     }
620   }
621 #pragma omp sections
622   {
623 #pragma omp task
624     {
625       bar();
626     }
627   }
628 #pragma omp sections
629   {
630 #pragma omp taskyield
631   }
632 #pragma omp sections
633   {
634 #pragma omp barrier // expected-error {{region cannot be closely nested inside 'sections' region}}
635   }
636 #pragma omp sections
637   {
638 #pragma omp taskwait
639   }
640 #pragma omp sections
641   {
642 #pragma omp flush
643   }
644 #pragma omp sections
645   {
646 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
647     bar();
648   }
649 #pragma omp sections
650   {
651 #pragma omp atomic
652     ++a;
653   }
654 #pragma omp sections
655   {
656 #pragma omp target
657     ++a;
658   }
659 #pragma omp sections
660   {
661 #pragma omp teams // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
662     ++a;
663   }
664 
665 // SECTION DIRECTIVE
666 #pragma omp section // expected-error {{orphaned 'omp section' directives are prohibited, it must be closely nested to a sections region}}
667   {
668     bar();
669   }
670 #pragma omp sections
671   {
672 #pragma omp section
673     {
674 #pragma omp for // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
675       for (int i = 0; i < 10; ++i)
676         ;
677     }
678   }
679 #pragma omp sections
680   {
681 #pragma omp section
682     {
683 #pragma omp simd
684       for (int i = 0; i < 10; ++i)
685         ;
686     }
687   }
688 #pragma omp sections
689   {
690 #pragma omp section
691     {
692 #pragma omp for simd // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}}
693       for (int i = 0; i < 10; ++i)
694         ;
695     }
696   }
697 #pragma omp sections
698   {
699 #pragma omp section
700     {
701 #pragma omp parallel
702       for (int i = 0; i < 10; ++i)
703         ;
704     }
705   }
706 #pragma omp sections
707   {
708 #pragma omp section
709     {
710 #pragma omp sections // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
711       {
712         bar();
713       }
714     }
715   }
716 #pragma omp sections
717   {
718 #pragma omp section
719     {
720 #pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a section region}}
721       {
722         bar();
723       }
724     }
725   }
726 #pragma omp sections
727   {
728 #pragma omp section
729     {
730 #pragma omp single // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
731       bar();
732 #pragma omp master // expected-error {{region cannot be closely nested inside 'section' region}}
733       bar();
734 #pragma omp critical
735       bar();
736     }
737   }
738 #pragma omp sections
739   {
740 #pragma omp section
741     {
742 #pragma omp parallel
743       {
744 #pragma omp single // OK
745         {
746           bar();
747         }
748 #pragma omp for // OK
749         for (int i = 0; i < 10; ++i)
750           ;
751 #pragma omp for simd // OK
752         for (int i = 0; i < 10; ++i)
753           ;
754 #pragma omp sections // OK
755         {
756           bar();
757         }
758       }
759     }
760   }
761 #pragma omp sections
762   {
763 #pragma omp section
764     {
765 #pragma omp parallel for
766       for (int i = 0; i < 10; ++i)
767         ;
768     }
769   }
770 #pragma omp sections
771   {
772 #pragma omp section
773     {
774 #pragma omp parallel for simd
775       for (int i = 0; i < 10; ++i)
776         ;
777     }
778   }
779 #pragma omp sections
780   {
781 #pragma omp section
782     {
783 #pragma omp parallel sections
784       {
785         bar();
786       }
787     }
788   }
789 #pragma omp sections
790   {
791 #pragma omp section
792     {
793 #pragma omp task
794       {
795         bar();
796       }
797     }
798   }
799 #pragma omp sections
800   {
801 #pragma omp section
802     {
803 #pragma omp taskyield
804       bar();
805     }
806   }
807 #pragma omp sections
808   {
809 #pragma omp section
810     {
811 #pragma omp barrier // expected-error {{region cannot be closely nested inside 'section' region}}
812       bar();
813     }
814   }
815 #pragma omp sections
816   {
817 #pragma omp section
818     {
819 #pragma omp taskwait
820       bar();
821     }
822   }
823 #pragma omp sections
824   {
825 #pragma omp section
826     {
827 #pragma omp flush
828       bar();
829     }
830   }
831 #pragma omp sections
832   {
833 #pragma omp section
834     {
835 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
836       bar();
837     }
838   }
839 #pragma omp sections
840   {
841 #pragma omp section
842 #pragma omp atomic
843     ++a;
844   }
845 #pragma omp sections
846   {
847 #pragma omp section
848 #pragma omp target
849     ++a;
850   }
851 #pragma omp sections
852   {
853 #pragma omp section
854 #pragma omp teams // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
855     ++a;
856   }
857 
858 // SINGLE DIRECTIVE
859 #pragma omp single
860   {
861 #pragma omp for // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
862     for (int i = 0; i < 10; ++i)
863       ;
864   }
865 #pragma omp single
866   {
867 #pragma omp simd
868     for (int i = 0; i < 10; ++i)
869       ;
870   }
871 #pragma omp single
872   {
873 #pragma omp for simd // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}}
874     for (int i = 0; i < 10; ++i)
875       ;
876   }
877 #pragma omp single
878   {
879 #pragma omp parallel
880     for (int i = 0; i < 10; ++i)
881       ;
882   }
883 #pragma omp single
884   {
885 #pragma omp single // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
886     {
887       bar();
888     }
889   }
890 #pragma omp single
891   {
892 #pragma omp master // expected-error {{region cannot be closely nested inside 'single' region}}
893     {
894       bar();
895     }
896   }
897 #pragma omp single
898   {
899 #pragma omp critical
900     {
901       bar();
902     }
903   }
904 #pragma omp single
905   {
906 #pragma omp sections // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
907     {
908       bar();
909     }
910   }
911 #pragma omp single
912   {
913 #pragma omp parallel
914     {
915 #pragma omp single // OK
916       {
917         bar();
918       }
919 #pragma omp for // OK
920       for (int i = 0; i < 10; ++i)
921         ;
922 #pragma omp for simd // OK
923       for (int i = 0; i < 10; ++i)
924         ;
925 #pragma omp sections // OK
926       {
927         bar();
928       }
929     }
930   }
931 #pragma omp single
932   {
933 #pragma omp parallel for
934     for (int i = 0; i < 10; ++i)
935       ;
936   }
937 #pragma omp single
938   {
939 #pragma omp parallel for simd
940     for (int i = 0; i < 10; ++i)
941       ;
942   }
943 #pragma omp single
944   {
945 #pragma omp parallel sections
946     {
947       bar();
948     }
949   }
950 #pragma omp single
951   {
952 #pragma omp task
953     {
954       bar();
955     }
956   }
957 #pragma omp single
958   {
959 #pragma omp taskyield
960     bar();
961   }
962 #pragma omp single
963   {
964 #pragma omp barrier // expected-error {{region cannot be closely nested inside 'single' region}}
965     bar();
966   }
967 #pragma omp single
968   {
969 #pragma omp taskwait
970     bar();
971   }
972 #pragma omp single
973   {
974 #pragma omp flush
975     bar();
976   }
977 #pragma omp single
978   {
979 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
980     bar();
981   }
982 #pragma omp single
983   {
984 #pragma omp atomic
985     ++a;
986   }
987 #pragma omp single
988   {
989 #pragma omp target
990     ++a;
991   }
992 #pragma omp single
993   {
994 #pragma omp teams // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
995     ++a;
996   }
997 
998 // MASTER DIRECTIVE
999 #pragma omp master
1000   {
1001 #pragma omp for // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
1002     for (int i = 0; i < 10; ++i)
1003       ;
1004   }
1005 #pragma omp master
1006   {
1007 #pragma omp simd
1008     for (int i = 0; i < 10; ++i)
1009       ;
1010   }
1011 #pragma omp master
1012   {
1013 #pragma omp for simd // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}}
1014     for (int i = 0; i < 10; ++i)
1015       ;
1016   }
1017 #pragma omp master
1018   {
1019 #pragma omp parallel
1020     for (int i = 0; i < 10; ++i)
1021       ;
1022   }
1023 #pragma omp master
1024   {
1025 #pragma omp single // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
1026     {
1027       bar();
1028     }
1029   }
1030 #pragma omp master
1031   {
1032 #pragma omp master // OK, though second 'master' is redundant
1033     {
1034       bar();
1035     }
1036   }
1037 #pragma omp master
1038   {
1039 #pragma omp critical
1040     {
1041       bar();
1042     }
1043   }
1044 #pragma omp master
1045   {
1046 #pragma omp sections // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
1047     {
1048       bar();
1049     }
1050   }
1051 #pragma omp master
1052   {
1053 #pragma omp parallel
1054     {
1055 #pragma omp master // OK
1056       {
1057         bar();
1058       }
1059 #pragma omp for // OK
1060       for (int i = 0; i < 10; ++i)
1061         ;
1062 #pragma omp for simd // OK
1063       for (int i = 0; i < 10; ++i)
1064         ;
1065 #pragma omp sections // OK
1066       {
1067         bar();
1068       }
1069     }
1070   }
1071 #pragma omp master
1072   {
1073 #pragma omp parallel for
1074     for (int i = 0; i < 10; ++i)
1075       ;
1076   }
1077 #pragma omp master
1078   {
1079 #pragma omp parallel for simd
1080     for (int i = 0; i < 10; ++i)
1081       ;
1082   }
1083 #pragma omp master
1084   {
1085 #pragma omp parallel sections
1086     {
1087       bar();
1088     }
1089   }
1090 #pragma omp master
1091   {
1092 #pragma omp task
1093     {
1094       bar();
1095     }
1096   }
1097 #pragma omp master
1098   {
1099 #pragma omp taskyield
1100     bar();
1101   }
1102 #pragma omp master
1103   {
1104 #pragma omp barrier // expected-error {{region cannot be closely nested inside 'master' region}}
1105     bar();
1106   }
1107 #pragma omp master
1108   {
1109 #pragma omp taskwait
1110     bar();
1111   }
1112 #pragma omp master
1113   {
1114 #pragma omp flush
1115     bar();
1116   }
1117 #pragma omp master
1118   {
1119 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
1120     bar();
1121   }
1122 #pragma omp master
1123   {
1124 #pragma omp atomic
1125     ++a;
1126   }
1127 #pragma omp master
1128   {
1129 #pragma omp target
1130     ++a;
1131   }
1132 #pragma omp master
1133   {
1134 #pragma omp teams // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
1135     ++a;
1136   }
1137 
1138 // CRITICAL DIRECTIVE
1139 #pragma omp critical
1140   {
1141 #pragma omp for // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
1142     for (int i = 0; i < 10; ++i)
1143       ;
1144   }
1145 #pragma omp critical
1146   {
1147 #pragma omp simd
1148     for (int i = 0; i < 10; ++i)
1149       ;
1150   }
1151 #pragma omp critical
1152   {
1153 #pragma omp for simd // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}}
1154     for (int i = 0; i < 10; ++i)
1155       ;
1156   }
1157 #pragma omp critical
1158   {
1159 #pragma omp parallel
1160     for (int i = 0; i < 10; ++i)
1161       ;
1162   }
1163 #pragma omp critical
1164   {
1165 #pragma omp single // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
1166     {
1167       bar();
1168     }
1169   }
1170 #pragma omp critical
1171   {
1172 #pragma omp master // OK, though second 'master' is redundant
1173     {
1174       bar();
1175     }
1176   }
1177 #pragma omp critical
1178   {
1179 #pragma omp critical
1180     {
1181       bar();
1182     }
1183   }
1184 #pragma omp critical
1185   {
1186 #pragma omp sections // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
1187     {
1188       bar();
1189     }
1190   }
1191 #pragma omp critical
1192   {
1193 #pragma omp parallel
1194     {
1195 #pragma omp master // OK
1196       {
1197         bar();
1198       }
1199 #pragma omp for // OK
1200       for (int i = 0; i < 10; ++i)
1201         ;
1202 #pragma omp for simd // OK
1203       for (int i = 0; i < 10; ++i)
1204         ;
1205 #pragma omp sections // OK
1206       {
1207         bar();
1208       }
1209     }
1210   }
1211 #pragma omp critical
1212   {
1213 #pragma omp parallel for
1214     for (int i = 0; i < 10; ++i)
1215       ;
1216   }
1217 #pragma omp critical
1218   {
1219 #pragma omp parallel for simd
1220     for (int i = 0; i < 10; ++i)
1221       ;
1222   }
1223 #pragma omp critical
1224   {
1225 #pragma omp parallel sections
1226     {
1227       bar();
1228     }
1229   }
1230 #pragma omp critical
1231   {
1232 #pragma omp task
1233     {
1234       bar();
1235     }
1236   }
1237 #pragma omp critical
1238   {
1239 #pragma omp taskyield
1240     bar();
1241   }
1242 #pragma omp critical
1243   {
1244 #pragma omp barrier // expected-error {{region cannot be closely nested inside 'critical' region}}
1245     bar();
1246   }
1247 #pragma omp critical
1248   {
1249 #pragma omp taskwait
1250     bar();
1251   }
1252 #pragma omp critical(Tuzik)
1253   {
1254 #pragma omp critical(grelka)
1255     bar();
1256   }
1257 #pragma omp critical(Belka) // expected-note {{previous 'critical' region starts here}}
1258   {
1259 #pragma omp critical(Belka) // expected-error {{cannot nest 'critical' regions having the same name 'Belka'}}
1260     {
1261 #pragma omp critical(Tuzik)
1262       {
1263 #pragma omp parallel
1264 #pragma omp critical(grelka)
1265         {
1266           bar();
1267         }
1268       }
1269     }
1270   }
1271 #pragma omp critical
1272   {
1273 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
1274     bar();
1275   }
1276 #pragma omp critical
1277   {
1278 #pragma omp atomic
1279     ++a;
1280   }
1281 #pragma omp critical
1282   {
1283 #pragma omp target
1284     ++a;
1285   }
1286 #pragma omp critical
1287   {
1288 #pragma omp teams // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
1289     ++a;
1290   }
1291 
1292 // PARALLEL FOR DIRECTIVE
1293 #pragma omp parallel for
1294   for (int i = 0; i < 10; ++i) {
1295 #pragma omp for // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
1296     for (int i = 0; i < 10; ++i)
1297       ;
1298   }
1299 #pragma omp parallel for
1300   for (int i = 0; i < 10; ++i) {
1301 #pragma omp simd
1302     for (int i = 0; i < 10; ++i)
1303       ;
1304   }
1305 #pragma omp parallel for
1306   for (int i = 0; i < 10; ++i) {
1307 #pragma omp for simd // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}}
1308     for (int i = 0; i < 10; ++i)
1309       ;
1310   }
1311 #pragma omp parallel for
1312   for (int i = 0; i < 10; ++i) {
1313 #pragma omp parallel
1314     for (int i = 0; i < 10; ++i)
1315       ;
1316   }
1317 #pragma omp parallel for
1318   for (int i = 0; i < 10; ++i) {
1319 #pragma omp sections // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
1320     {
1321       bar();
1322     }
1323   }
1324 #pragma omp parallel for
1325   for (int i = 0; i < 10; ++i) {
1326 #pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a parallel for region}}
1327     {
1328       bar();
1329     }
1330   }
1331 #pragma omp parallel for
1332   for (int i = 0; i < 10; ++i) {
1333 #pragma omp single // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
1334     {
1335       bar();
1336     }
1337   }
1338 
1339 #pragma omp parallel for
1340   for (int i = 0; i < 10; ++i) {
1341 #pragma omp master // expected-error {{region cannot be closely nested inside 'parallel for' region}}
1342     {
1343       bar();
1344     }
1345   }
1346 
1347 #pragma omp parallel for
1348   for (int i = 0; i < 10; ++i) {
1349 #pragma omp critical
1350     {
1351       bar();
1352     }
1353   }
1354 
1355 #pragma omp parallel for
1356   for (int i = 0; i < 10; ++i) {
1357 #pragma omp parallel
1358     {
1359 #pragma omp single // OK
1360       {
1361         bar();
1362       }
1363 #pragma omp for // OK
1364       for (int i = 0; i < 10; ++i)
1365         ;
1366 #pragma omp for simd // OK
1367       for (int i = 0; i < 10; ++i)
1368         ;
1369 #pragma omp sections // OK
1370       {
1371         bar();
1372       }
1373     }
1374   }
1375 #pragma omp parallel for
1376   for (int i = 0; i < 10; ++i) {
1377 #pragma omp parallel for
1378     for (int i = 0; i < 10; ++i)
1379       ;
1380   }
1381 #pragma omp parallel for
1382   for (int i = 0; i < 10; ++i) {
1383 #pragma omp parallel for simd
1384     for (int i = 0; i < 10; ++i)
1385       ;
1386   }
1387 #pragma omp parallel for
1388   for (int i = 0; i < 10; ++i) {
1389 #pragma omp parallel sections
1390     {
1391       bar();
1392     }
1393   }
1394 #pragma omp parallel for
1395   for (int i = 0; i < 10; ++i) {
1396 #pragma omp task
1397     {
1398       bar();
1399     }
1400   }
1401 #pragma omp parallel for
1402   for (int i = 0; i < 10; ++i) {
1403 #pragma omp taskyield
1404     bar();
1405   }
1406 #pragma omp parallel for
1407   for (int i = 0; i < 10; ++i) {
1408 #pragma omp barrier // expected-error {{region cannot be closely nested inside 'parallel for' region}}
1409     bar();
1410   }
1411 #pragma omp parallel for
1412   for (int i = 0; i < 10; ++i) {
1413 #pragma omp taskwait
1414     bar();
1415   }
1416 #pragma omp parallel for
1417   for (int i = 0; i < 10; ++i) {
1418 #pragma omp flush
1419     bar();
1420   }
1421 #pragma omp parallel for
1422   for (int i = 0; i < 10; ++i) {
1423 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
1424     bar();
1425   }
1426 #pragma omp parallel for ordered
1427   for (int i = 0; i < 10; ++i) {
1428 #pragma omp ordered // OK
1429     bar();
1430   }
1431 #pragma omp parallel for
1432   for (int i = 0; i < 10; ++i) {
1433 #pragma omp atomic
1434     ++a;
1435   }
1436 #pragma omp parallel for
1437   for (int i = 0; i < 10; ++i) {
1438 #pragma omp target
1439     ++a;
1440   }
1441 #pragma omp parallel for
1442   for (int i = 0; i < 10; ++i) {
1443 #pragma omp teams // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
1444     ++a;
1445   }
1446 
1447 // PARALLEL FOR SIMD DIRECTIVE
1448 #pragma omp parallel for simd
1449   for (int i = 0; i < 10; ++i) {
1450 #pragma omp for // expected-error {{OpenMP constructs may not be nested inside a simd region}}
1451     for (int i = 0; i < 10; ++i)
1452       ;
1453   }
1454 #pragma omp parallel for simd
1455   for (int i = 0; i < 10; ++i) {
1456 #pragma omp simd// expected-error {{OpenMP constructs may not be nested inside a simd region}}
1457     for (int i = 0; i < 10; ++i)
1458       ;
1459   }
1460 #pragma omp parallel for simd
1461   for (int i = 0; i < 10; ++i) {
1462 #pragma omp for simd // expected-error {{OpenMP constructs may not be nested inside a simd region}}
1463     for (int i = 0; i < 10; ++i)
1464       ;
1465   }
1466 #pragma omp parallel for simd
1467   for (int i = 0; i < 10; ++i) {
1468 #pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}}
1469     for (int i = 0; i < 10; ++i)
1470       ;
1471   }
1472 #pragma omp parallel for simd
1473   for (int i = 0; i < 10; ++i) {
1474 #pragma omp sections // expected-error {{OpenMP constructs may not be nested inside a simd region}}
1475     {
1476       bar();
1477     }
1478   }
1479 #pragma omp parallel for simd
1480   for (int i = 0; i < 10; ++i) {
1481 #pragma omp section // expected-error {{OpenMP constructs may not be nested inside a simd region}}
1482     {
1483       bar();
1484     }
1485   }
1486 #pragma omp parallel for simd
1487   for (int i = 0; i < 10; ++i) {
1488 #pragma omp single // expected-error {{OpenMP constructs may not be nested inside a simd region}}
1489     {
1490       bar();
1491     }
1492   }
1493 
1494 #pragma omp parallel for simd
1495   for (int i = 0; i < 10; ++i) {
1496 #pragma omp master // expected-error {{OpenMP constructs may not be nested inside a simd region}}
1497     {
1498       bar();
1499     }
1500   }
1501 
1502 #pragma omp parallel for simd
1503   for (int i = 0; i < 10; ++i) {
1504 #pragma omp critical // expected-error {{OpenMP constructs may not be nested inside a simd region}}
1505     {
1506       bar();
1507     }
1508   }
1509 
1510 #pragma omp parallel for simd
1511   for (int i = 0; i < 10; ++i) {
1512 #pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}}
1513     {
1514 #pragma omp single
1515       {
1516         bar();
1517       }
1518 #pragma omp for
1519       for (int i = 0; i < 10; ++i)
1520         ;
1521 #pragma omp for simd
1522       for (int i = 0; i < 10; ++i)
1523         ;
1524 #pragma omp sections
1525       {
1526         bar();
1527       }
1528     }
1529   }
1530 #pragma omp parallel for simd
1531   for (int i = 0; i < 10; ++i) {
1532 #pragma omp parallel for // expected-error {{OpenMP constructs may not be nested inside a simd region}}
1533     for (int i = 0; i < 10; ++i)
1534       ;
1535   }
1536 #pragma omp parallel for simd
1537   for (int i = 0; i < 10; ++i) {
1538 #pragma omp parallel for simd// expected-error {{OpenMP constructs may not be nested inside a simd region}}
1539     for (int i = 0; i < 10; ++i)
1540       ;
1541   }
1542 #pragma omp parallel for simd
1543   for (int i = 0; i < 10; ++i) {
1544 #pragma omp parallel sections // expected-error {{OpenMP constructs may not be nested inside a simd region}}
1545     {
1546       bar();
1547     }
1548   }
1549 #pragma omp parallel for simd
1550   for (int i = 0; i < 10; ++i) {
1551 #pragma omp task // expected-error {{OpenMP constructs may not be nested inside a simd region}}
1552     {
1553       bar();
1554     }
1555   }
1556 #pragma omp parallel for simd
1557   for (int i = 0; i < 10; ++i) {
1558 #pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}}
1559     bar();
1560   }
1561 #pragma omp parallel for simd
1562   for (int i = 0; i < 10; ++i) {
1563 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
1564     bar();
1565   }
1566 #pragma omp parallel for simd
1567   for (int i = 0; i < 10; ++i) {
1568 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
1569     bar();
1570   }
1571 #pragma omp parallel for simd
1572   for (int i = 0; i < 10; ++i) {
1573 #pragma omp flush // expected-error {{OpenMP constructs may not be nested inside a simd region}}
1574     bar();
1575   }
1576 #pragma omp parallel for simd
1577   for (int i = 0; i < 10; ++i) {
1578 #pragma omp ordered // expected-error {{OpenMP constructs may not be nested inside a simd region}}
1579     bar();
1580   }
1581 #pragma omp parallel for simd
1582   for (int i = 0; i < 10; ++i) {
1583 #pragma omp ordered // expected-error {{OpenMP constructs may not be nested inside a simd region}}
1584     bar();
1585   }
1586 #pragma omp parallel for simd
1587   for (int i = 0; i < 10; ++i) {
1588 #pragma omp atomic // expected-error {{OpenMP constructs may not be nested inside a simd region}}
1589     ++a;
1590   }
1591 #pragma omp parallel for simd
1592   for (int i = 0; i < 10; ++i) {
1593 #pragma omp target // expected-error {{OpenMP constructs may not be nested inside a simd region}}
1594     ++a;
1595   }
1596 #pragma omp parallel for simd
1597   for (int i = 0; i < 10; ++i) {
1598 #pragma omp teams // expected-error {{OpenMP constructs may not be nested inside a simd region}}
1599     ++a;
1600   }
1601 
1602 // PARALLEL SECTIONS DIRECTIVE
1603 #pragma omp parallel sections
1604   {
1605 #pragma omp for // expected-error {{region cannot be closely nested inside 'parallel sections' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
1606     for (int i = 0; i < 10; ++i)
1607       ;
1608   }
1609 #pragma omp parallel sections
1610   {
1611 #pragma omp simd
1612     for (int i = 0; i < 10; ++i)
1613       ;
1614   }
1615 #pragma omp parallel sections
1616   {
1617 #pragma omp for simd // expected-error {{region cannot be closely nested inside 'parallel sections' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}}
1618     for (int i = 0; i < 10; ++i)
1619       ;
1620   }
1621 #pragma omp parallel sections
1622   {
1623 #pragma omp parallel
1624     for (int i = 0; i < 10; ++i)
1625       ;
1626   }
1627 #pragma omp parallel sections
1628   {
1629 #pragma omp sections // expected-error {{region cannot be closely nested inside 'parallel sections' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
1630     {
1631       bar();
1632     }
1633   }
1634 #pragma omp parallel sections
1635   {
1636 #pragma omp section
1637     {
1638       bar();
1639     }
1640   }
1641 #pragma omp parallel sections
1642   {
1643 #pragma omp section
1644     {
1645 #pragma omp single // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
1646       bar();
1647     }
1648   }
1649 #pragma omp parallel sections
1650   {
1651 #pragma omp section
1652     {
1653 #pragma omp master // expected-error {{region cannot be closely nested inside 'section' region}}
1654       bar();
1655     }
1656   }
1657 #pragma omp parallel sections
1658   {
1659 #pragma omp section
1660     {
1661 #pragma omp critical
1662       bar();
1663     }
1664   }
1665 #pragma omp parallel sections
1666   {
1667 #pragma omp parallel
1668     {
1669 #pragma omp single // OK
1670       {
1671         bar();
1672       }
1673 #pragma omp for // OK
1674       for (int i = 0; i < 10; ++i)
1675         ;
1676 #pragma omp for simd // OK
1677       for (int i = 0; i < 10; ++i)
1678         ;
1679 #pragma omp sections // OK
1680       {
1681         bar();
1682       }
1683     }
1684   }
1685 #pragma omp parallel sections
1686   {
1687 #pragma omp parallel for
1688     for (int i = 0; i < 10; ++i)
1689       ;
1690   }
1691 #pragma omp parallel sections
1692   {
1693 #pragma omp parallel for simd
1694     for (int i = 0; i < 10; ++i)
1695       ;
1696   }
1697 #pragma omp parallel sections
1698   {
1699 #pragma omp parallel sections
1700     {
1701       bar();
1702     }
1703   }
1704 #pragma omp parallel sections
1705   {
1706 #pragma omp task
1707     {
1708       bar();
1709     }
1710   }
1711 #pragma omp parallel sections
1712   {
1713 #pragma omp taskyield
1714   }
1715 #pragma omp parallel sections
1716   {
1717 #pragma omp barrier // expected-error {{region cannot be closely nested inside 'parallel sections' region}}
1718   }
1719 #pragma omp parallel sections
1720   {
1721 #pragma omp taskwait
1722   }
1723 #pragma omp parallel sections
1724   {
1725 #pragma omp flush
1726   }
1727 #pragma omp parallel sections
1728   {
1729 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'parallel sections' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
1730     bar();
1731   }
1732 #pragma omp parallel sections
1733   {
1734 #pragma omp atomic
1735     ++a;
1736   }
1737 #pragma omp parallel sections
1738   {
1739 #pragma omp target
1740     ++a;
1741   }
1742 #pragma omp parallel sections
1743   {
1744 #pragma omp teams // expected-error {{region cannot be closely nested inside 'parallel sections' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
1745     ++a;
1746   }
1747 
1748 // TASK DIRECTIVE
1749 #pragma omp task
1750 #pragma omp for // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
1751   for (int i = 0; i < 10; ++i)
1752     ;
1753 #pragma omp task
1754 #pragma omp simd
1755   for (int i = 0; i < 10; ++i)
1756     ;
1757 #pragma omp task
1758 #pragma omp for simd // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}}
1759   for (int i = 0; i < 10; ++i)
1760     ;
1761 #pragma omp task
1762 #pragma omp sections // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
1763   {
1764     bar();
1765   }
1766 #pragma omp task
1767 #pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a task region}}
1768   {
1769     bar();
1770   }
1771 #pragma omp task
1772 #pragma omp single // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
1773   bar();
1774 #pragma omp task
1775 #pragma omp master // expected-error {{region cannot be closely nested inside 'task' region}}
1776   bar();
1777 #pragma omp task
1778 #pragma omp critical
1779   bar();
1780 
1781 #pragma omp task
1782 #pragma omp parallel for
1783   for (int i = 0; i < 10; ++i)
1784     ;
1785 #pragma omp task
1786 #pragma omp parallel for simd
1787   for (int i = 0; i < 10; ++i)
1788     ;
1789 #pragma omp task
1790 #pragma omp parallel sections
1791   {
1792     bar();
1793   }
1794 #pragma omp task
1795 #pragma omp task
1796   {
1797     bar();
1798   }
1799 #pragma omp task
1800   {
1801 #pragma omp taskyield
1802     bar();
1803   }
1804 #pragma omp task
1805   {
1806 #pragma omp barrier // expected-error {{region cannot be closely nested inside 'task' region}}
1807     bar();
1808   }
1809 #pragma omp task
1810   {
1811 #pragma omp taskwait
1812     bar();
1813   }
1814 #pragma omp task
1815   {
1816 #pragma omp flush
1817     bar();
1818   }
1819 #pragma omp task
1820   {
1821 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
1822     bar();
1823   }
1824 #pragma omp task
1825   {
1826 #pragma omp atomic
1827     ++a;
1828   }
1829 #pragma omp task
1830   {
1831 #pragma omp target
1832     ++a;
1833   }
1834 #pragma omp task
1835   {
1836 #pragma omp teams // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
1837     ++a;
1838   }
1839 
1840 // ORDERED DIRECTIVE
1841 #pragma omp ordered
1842   {
1843 #pragma omp for // expected-error {{region cannot be closely nested inside 'ordered' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
1844     for (int i = 0; i < 10; ++i)
1845       ;
1846   }
1847 #pragma omp ordered
1848   {
1849 #pragma omp simd
1850     for (int i = 0; i < 10; ++i)
1851       ;
1852   }
1853 #pragma omp ordered
1854   {
1855 #pragma omp for simd // expected-error {{region cannot be closely nested inside 'ordered' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}}
1856     for (int i = 0; i < 10; ++i)
1857       ;
1858   }
1859 #pragma omp ordered
1860   {
1861 #pragma omp parallel
1862     for (int i = 0; i < 10; ++i)
1863       ;
1864   }
1865 #pragma omp ordered
1866   {
1867 #pragma omp single // expected-error {{region cannot be closely nested inside 'ordered' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
1868     {
1869       bar();
1870     }
1871   }
1872 #pragma omp ordered
1873   {
1874 #pragma omp master // OK, though second 'ordered' is redundant
1875     {
1876       bar();
1877     }
1878   }
1879 #pragma omp ordered
1880   {
1881 #pragma omp critical
1882     {
1883       bar();
1884     }
1885   }
1886 #pragma omp ordered
1887   {
1888 #pragma omp sections // expected-error {{region cannot be closely nested inside 'ordered' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
1889     {
1890       bar();
1891     }
1892   }
1893 #pragma omp ordered
1894   {
1895 #pragma omp parallel for ordered
1896     for (int j = 0; j < 10; ++j) {
1897 #pragma omp ordered // OK
1898       {
1899         bar();
1900       }
1901     }
1902   }
1903 #pragma omp ordered
1904   {
1905 #pragma omp parallel for simd ordered //expected-error {{unexpected OpenMP clause 'ordered' in directive '#pragma omp parallel for simd'}}
1906     for (int j = 0; j < 10; ++j) {
1907 #pragma omp ordered // expected-error {{OpenMP constructs may not be nested inside a simd region}}
1908       {
1909         bar();
1910       }
1911     }
1912   }
1913 #pragma omp ordered
1914   {
1915 #pragma omp parallel for
1916     for (int i = 0; i < 10; ++i)
1917       ;
1918   }
1919 #pragma omp ordered
1920   {
1921 #pragma omp parallel for simd
1922     for (int i = 0; i < 10; ++i)
1923       ;
1924   }
1925 #pragma omp ordered
1926   {
1927 #pragma omp parallel sections
1928     {
1929       bar();
1930     }
1931   }
1932 #pragma omp ordered
1933   {
1934 #pragma omp task
1935     {
1936       bar();
1937     }
1938   }
1939 #pragma omp ordered
1940   {
1941 #pragma omp taskyield
1942     bar();
1943   }
1944 #pragma omp ordered
1945   {
1946 #pragma omp barrier // expected-error {{region cannot be closely nested inside 'ordered' region}}
1947     bar();
1948   }
1949 #pragma omp ordered
1950   {
1951 #pragma omp taskwait
1952     bar();
1953   }
1954 #pragma omp ordered
1955   {
1956 #pragma omp flush
1957     bar();
1958   }
1959 #pragma omp ordered
1960   {
1961 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'ordered' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
1962     bar();
1963   }
1964 #pragma omp ordered
1965   {
1966 #pragma omp atomic
1967     ++a;
1968   }
1969 #pragma omp ordered
1970   {
1971 #pragma omp target
1972     ++a;
1973   }
1974 #pragma omp ordered
1975   {
1976 #pragma omp teams // expected-error {{region cannot be closely nested inside 'ordered' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
1977     ++a;
1978   }
1979 
1980 // ATOMIC DIRECTIVE
1981 #pragma omp atomic
1982   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
1983   {
1984 #pragma omp for // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
1985     for (int i = 0; i < 10; ++i)
1986       ;
1987   }
1988 #pragma omp atomic
1989   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
1990   {
1991 #pragma omp simd // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
1992     for (int i = 0; i < 10; ++i)
1993       ;
1994   }
1995 #pragma omp atomic
1996   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
1997   {
1998 #pragma omp for simd // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
1999     for (int i = 0; i < 10; ++i)
2000       ;
2001   }
2002 #pragma omp atomic
2003   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
2004   {
2005 #pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
2006     for (int i = 0; i < 10; ++i)
2007       ;
2008   }
2009 #pragma omp atomic
2010   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
2011   {
2012 #pragma omp sections // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
2013     {
2014       bar();
2015     }
2016   }
2017 #pragma omp atomic
2018   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
2019   {
2020 #pragma omp section // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
2021     {
2022       bar();
2023     }
2024   }
2025 #pragma omp atomic
2026   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
2027   {
2028 #pragma omp single // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
2029     {
2030       bar();
2031     }
2032   }
2033 #pragma omp atomic
2034   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
2035   {
2036 #pragma omp master // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
2037     {
2038       bar();
2039     }
2040   }
2041 #pragma omp atomic
2042   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
2043   {
2044 #pragma omp critical // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
2045     {
2046       bar();
2047     }
2048   }
2049 #pragma omp atomic
2050   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
2051   {
2052 #pragma omp parallel for // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
2053     for (int i = 0; i < 10; ++i)
2054       ;
2055   }
2056 #pragma omp atomic
2057   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
2058   {
2059 #pragma omp parallel for simd // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
2060     for (int i = 0; i < 10; ++i)
2061       ;
2062   }
2063 #pragma omp atomic
2064   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
2065   {
2066 #pragma omp parallel sections // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
2067     {
2068       bar();
2069     }
2070   }
2071 #pragma omp atomic
2072   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
2073   {
2074 #pragma omp task // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
2075     {
2076       bar();
2077     }
2078   }
2079 #pragma omp atomic
2080   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
2081   {
2082 #pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
2083     bar();
2084   }
2085 #pragma omp atomic
2086   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
2087   {
2088 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
2089     bar();
2090   }
2091 #pragma omp atomic
2092   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
2093   {
2094 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
2095     bar();
2096   }
2097 #pragma omp atomic
2098   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
2099   {
2100 #pragma omp flush // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
2101     bar();
2102   }
2103 #pragma omp atomic
2104   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
2105   {
2106 #pragma omp ordered // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
2107     bar();
2108   }
2109 #pragma omp atomic
2110   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
2111   {
2112 #pragma omp atomic // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
2113     ++a;
2114   }
2115 #pragma omp atomic
2116   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
2117   {
2118 #pragma omp target // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
2119     ++a;
2120   }
2121 #pragma omp atomic
2122   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
2123   {
2124 #pragma omp teams // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
2125     ++a;
2126   }
2127 
2128 // TARGET DIRECTIVE
2129 #pragma omp target
2130 #pragma omp parallel
2131   bar();
2132 #pragma omp target
2133 #pragma omp for
2134   for (int i = 0; i < 10; ++i)
2135     ;
2136 #pragma omp target
2137 #pragma omp simd
2138   for (int i = 0; i < 10; ++i)
2139     ;
2140 #pragma omp target
2141 #pragma omp for simd
2142   for (int i = 0; i < 10; ++i)
2143     ;
2144 #pragma omp target
2145 #pragma omp sections
2146   {
2147     bar();
2148   }
2149 #pragma omp target
2150 #pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a target region}}
2151   {
2152     bar();
2153   }
2154 #pragma omp target
2155 #pragma omp single
2156   bar();
2157 
2158 #pragma omp target
2159 #pragma omp master
2160   {
2161     bar();
2162   }
2163 #pragma omp target
2164 #pragma omp critical
2165   {
2166     bar();
2167   }
2168 #pragma omp target
2169 #pragma omp parallel for
2170   for (int i = 0; i < 10; ++i)
2171     ;
2172 #pragma omp target
2173 #pragma omp parallel for simd
2174   for (int i = 0; i < 10; ++i)
2175     ;
2176 #pragma omp target
2177 #pragma omp parallel sections
2178   {
2179     bar();
2180   }
2181 #pragma omp target
2182 #pragma omp task
2183   {
2184     bar();
2185   }
2186 #pragma omp target
2187   {
2188 #pragma omp taskyield
2189     bar();
2190   }
2191 #pragma omp target
2192   {
2193 #pragma omp barrier
2194     bar();
2195   }
2196 #pragma omp target
2197   {
2198 #pragma omp taskwait
2199     bar();
2200   }
2201 #pragma omp target
2202   {
2203 #pragma omp flush
2204     bar();
2205   }
2206 #pragma omp target
2207   {
2208 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'target' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
2209     bar();
2210   }
2211 #pragma omp target
2212   {
2213 #pragma omp atomic
2214     ++a;
2215   }
2216 #pragma omp target
2217   {
2218 #pragma omp target
2219     ++a;
2220   }
2221 #pragma omp target
2222   {
2223 #pragma omp teams
2224     ++a;
2225   }
2226 #pragma omp target // expected-error {{target construct with nested teams region contains statements outside of the teams construct}}
2227   {
2228     ++a;           // expected-note {{statement outside teams construct here}}
2229 #pragma omp teams  // expected-note {{nested teams construct here}}
2230     ++a;
2231   }
2232 
2233 // TEAMS DIRECTIVE
2234 #pragma omp target
2235 #pragma omp teams
2236 #pragma omp parallel
2237   bar();
2238 #pragma omp target
2239 #pragma omp teams
2240 #pragma omp for // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
2241   for (int i = 0; i < 10; ++i)
2242     ;
2243 #pragma omp target
2244 #pragma omp teams
2245 #pragma omp simd // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp simd' directive into a parallel region?}}
2246   for (int i = 0; i < 10; ++i)
2247     ;
2248 #pragma omp target
2249 #pragma omp teams
2250 #pragma omp for simd // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}}
2251   for (int i = 0; i < 10; ++i)
2252     ;
2253 #pragma omp target
2254 #pragma omp teams
2255 #pragma omp sections // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
2256   {
2257     bar();
2258   }
2259 #pragma omp target
2260 #pragma omp teams
2261 #pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a teams region}}
2262   {
2263     bar();
2264   }
2265 #pragma omp target
2266 #pragma omp teams
2267 #pragma omp single // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
2268   bar();
2269 
2270 #pragma omp target
2271 #pragma omp teams
2272 #pragma omp master // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp master' directive into a parallel region?}}
2273   {
2274     bar();
2275   }
2276 #pragma omp target
2277 #pragma omp teams
2278 #pragma omp critical // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp critical' directive into a parallel region?}}
2279   {
2280     bar();
2281   }
2282 #pragma omp target
2283 #pragma omp teams
2284 #pragma omp parallel for
2285   for (int i = 0; i < 10; ++i)
2286     ;
2287 #pragma omp target
2288 #pragma omp teams
2289 #pragma omp parallel for simd
2290   for (int i = 0; i < 10; ++i)
2291     ;
2292 #pragma omp target
2293 #pragma omp teams
2294 #pragma omp parallel sections
2295   {
2296     bar();
2297   }
2298 #pragma omp target
2299 #pragma omp teams
2300 #pragma omp task // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp task' directive into a parallel region?}}
2301   {
2302     bar();
2303   }
2304 #pragma omp target
2305 #pragma omp teams
2306   {
2307 #pragma omp taskyield // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp taskyield' directive into a parallel region?}}
2308     bar();
2309   }
2310 #pragma omp target
2311 #pragma omp teams
2312   {
2313 #pragma omp barrier // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp barrier' directive into a parallel region?}}
2314     bar();
2315   }
2316 #pragma omp target
2317 #pragma omp teams
2318   {
2319 #pragma omp taskwait // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp taskwait' directive into a parallel region?}}
2320     bar();
2321   }
2322 #pragma omp target
2323 #pragma omp teams
2324   {
2325 #pragma omp flush // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp flush' directive into a parallel region?}}
2326     bar();
2327   }
2328 #pragma omp target
2329 #pragma omp teams
2330   {
2331 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
2332     bar();
2333   }
2334 #pragma omp target
2335 #pragma omp teams
2336   {
2337 #pragma omp atomic // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp atomic' directive into a parallel region?}}
2338     ++a;
2339   }
2340 #pragma omp target
2341 #pragma omp teams
2342   {
2343 #pragma omp target // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp target' directive into a parallel region?}}
2344     ++a;
2345   }
2346 #pragma omp target
2347 #pragma omp teams
2348   {
2349 #pragma omp teams // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
2350     ++a;
2351   }
2352 }
2353 
2354 void foo() {
2355   int a = 0;
2356 // PARALLEL DIRECTIVE
2357 #pragma omp parallel
2358 #pragma omp for
2359   for (int i = 0; i < 10; ++i)
2360     ;
2361 #pragma omp parallel
2362 #pragma omp simd
2363   for (int i = 0; i < 10; ++i)
2364     ;
2365 #pragma omp parallel
2366 #pragma omp for simd
2367   for (int i = 0; i < 10; ++i)
2368     ;
2369 #pragma omp parallel
2370 #pragma omp sections
2371   {
2372     bar();
2373   }
2374 #pragma omp parallel
2375 #pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a parallel region}}
2376   {
2377     bar();
2378   }
2379 #pragma omp parallel
2380 #pragma omp sections
2381   {
2382     bar();
2383   }
2384 #pragma omp parallel
2385 #pragma omp single
2386   bar();
2387 #pragma omp parallel
2388 #pragma omp master
2389   bar();
2390 #pragma omp parallel
2391 #pragma omp critical
2392   bar();
2393 #pragma omp parallel
2394 #pragma omp parallel for
2395   for (int i = 0; i < 10; ++i)
2396     ;
2397 #pragma omp parallel
2398 #pragma omp parallel for simd
2399   for (int i = 0; i < 10; ++i)
2400     ;
2401 #pragma omp parallel
2402 #pragma omp parallel sections
2403   {
2404     bar();
2405   }
2406 #pragma omp parallel
2407 #pragma omp task
2408   {
2409     bar();
2410   }
2411 #pragma omp parallel
2412   {
2413 #pragma omp taskyield
2414     bar();
2415   }
2416 #pragma omp parallel
2417   {
2418 #pragma omp barrier
2419     bar();
2420   }
2421 #pragma omp parallel
2422   {
2423 #pragma omp taskwait
2424     bar();
2425   }
2426 #pragma omp parallel
2427   {
2428 #pragma omp flush
2429     bar();
2430   }
2431 #pragma omp parallel
2432   {
2433 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'parallel' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
2434     bar();
2435   }
2436 #pragma omp parallel
2437   {
2438 #pragma omp atomic
2439     ++a;
2440   }
2441 #pragma omp parallel
2442   {
2443 #pragma omp target
2444     ++a;
2445   }
2446 #pragma omp parallel
2447   {
2448 #pragma omp teams // expected-error {{region cannot be closely nested inside 'parallel' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
2449     ++a;
2450   }
2451 
2452 // SIMD DIRECTIVE
2453 #pragma omp simd
2454   for (int i = 0; i < 10; ++i) {
2455 #pragma omp for // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2456     for (int i = 0; i < 10; ++i)
2457       ;
2458   }
2459 #pragma omp simd
2460   for (int i = 0; i < 10; ++i) {
2461 #pragma omp simd // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2462     for (int i = 0; i < 10; ++i)
2463       ;
2464   }
2465 #pragma omp simd
2466   for (int i = 0; i < 10; ++i) {
2467 #pragma omp for simd // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2468     for (int i = 0; i < 10; ++i)
2469       ;
2470   }
2471 #pragma omp simd
2472   for (int i = 0; i < 10; ++i) {
2473 #pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2474     for (int i = 0; i < 10; ++i)
2475       ;
2476   }
2477 #pragma omp simd
2478   for (int i = 0; i < 10; ++i) {
2479 #pragma omp sections // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2480     {
2481       bar();
2482     }
2483   }
2484 #pragma omp simd
2485   for (int i = 0; i < 10; ++i) {
2486 #pragma omp section // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2487     {
2488       bar();
2489     }
2490   }
2491 #pragma omp simd
2492   for (int i = 0; i < 10; ++i) {
2493 #pragma omp single // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2494     bar();
2495 #pragma omp master // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2496     bar();
2497   }
2498 #pragma omp simd
2499   for (int i = 0; i < 10; ++i) {
2500 #pragma omp single // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2501     bar();
2502 #pragma omp critical // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2503     bar();
2504   }
2505 #pragma omp simd
2506   for (int i = 0; i < 10; ++i) {
2507 #pragma omp parallel for // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2508     for (int i = 0; i < 10; ++i)
2509       ;
2510   }
2511 #pragma omp simd
2512   for (int i = 0; i < 10; ++i) {
2513 #pragma omp parallel for simd // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2514     for (int i = 0; i < 10; ++i)
2515       ;
2516   }
2517 #pragma omp simd
2518   for (int i = 0; i < 10; ++i) {
2519 #pragma omp parallel sections // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2520     {
2521       bar();
2522     }
2523   }
2524 #pragma omp simd
2525   for (int i = 0; i < 10; ++i) {
2526 #pragma omp task // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2527     {
2528       bar();
2529     }
2530   }
2531 #pragma omp simd
2532   for (int i = 0; i < 10; ++i) {
2533 #pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2534     bar();
2535   }
2536 #pragma omp simd
2537   for (int i = 0; i < 10; ++i) {
2538 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2539     bar();
2540   }
2541 #pragma omp simd
2542   for (int i = 0; i < 10; ++i) {
2543 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2544     bar();
2545   }
2546 #pragma omp simd
2547   for (int i = 0; i < 10; ++i) {
2548 #pragma omp flush // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2549     bar();
2550   }
2551 #pragma omp simd
2552   for (int i = 0; i < 10; ++i) {
2553 #pragma omp ordered // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2554     bar();
2555   }
2556 #pragma omp simd
2557   for (int i = 0; i < 10; ++i) {
2558 #pragma omp atomic // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2559     ++a;
2560   }
2561 #pragma omp simd
2562   for (int i = 0; i < 10; ++i) {
2563 #pragma omp target // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2564     ++a;
2565   }
2566 #pragma omp simd
2567   for (int i = 0; i < 10; ++i) {
2568 #pragma omp teams // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2569     ++a;
2570   }
2571 
2572 // FOR DIRECTIVE
2573 #pragma omp for
2574   for (int i = 0; i < 10; ++i) {
2575 #pragma omp for // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
2576     for (int i = 0; i < 10; ++i)
2577       ;
2578   }
2579 #pragma omp for
2580   for (int i = 0; i < 10; ++i) {
2581 #pragma omp simd
2582     for (int i = 0; i < 10; ++i)
2583       ;
2584   }
2585 #pragma omp for
2586   for (int i = 0; i < 10; ++i) {
2587 #pragma omp for simd // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}}
2588     for (int i = 0; i < 10; ++i)
2589       ;
2590   }
2591 #pragma omp for
2592   for (int i = 0; i < 10; ++i) {
2593 #pragma omp parallel
2594     for (int i = 0; i < 10; ++i)
2595       ;
2596   }
2597 #pragma omp for
2598   for (int i = 0; i < 10; ++i) {
2599 #pragma omp sections // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
2600     {
2601       bar();
2602     }
2603   }
2604 #pragma omp for
2605   for (int i = 0; i < 10; ++i) {
2606 #pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a for region}}
2607     {
2608       bar();
2609     }
2610   }
2611 #pragma omp for
2612   for (int i = 0; i < 10; ++i) {
2613 #pragma omp single // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
2614     bar();
2615 #pragma omp master // expected-error {{region cannot be closely nested inside 'for' region}}
2616     bar();
2617 #pragma omp critical
2618     bar();
2619   }
2620 #pragma omp for
2621   for (int i = 0; i < 10; ++i) {
2622 #pragma omp parallel
2623     {
2624 #pragma omp single // OK
2625       {
2626         bar();
2627       }
2628 #pragma omp for // OK
2629       for (int i = 0; i < 10; ++i)
2630         ;
2631 #pragma omp for simd // OK
2632       for (int i = 0; i < 10; ++i)
2633         ;
2634 #pragma omp sections // OK
2635       {
2636         bar();
2637       }
2638     }
2639   }
2640 #pragma omp for
2641   for (int i = 0; i < 10; ++i) {
2642 #pragma omp parallel for
2643     for (int i = 0; i < 10; ++i)
2644       ;
2645   }
2646 #pragma omp for
2647   for (int i = 0; i < 10; ++i) {
2648 #pragma omp parallel for simd
2649     for (int i = 0; i < 10; ++i)
2650       ;
2651   }
2652 #pragma omp for
2653   for (int i = 0; i < 10; ++i) {
2654 #pragma omp parallel sections
2655     {
2656       bar();
2657     }
2658   }
2659 #pragma omp for
2660   for (int i = 0; i < 10; ++i) {
2661 #pragma omp task
2662     {
2663       bar();
2664     }
2665   }
2666 #pragma omp for
2667   for (int i = 0; i < 10; ++i) {
2668 #pragma omp taskyield
2669     bar();
2670   }
2671 #pragma omp for
2672   for (int i = 0; i < 10; ++i) {
2673 #pragma omp barrier // expected-error {{region cannot be closely nested inside 'for' region}}
2674     bar();
2675   }
2676 #pragma omp for
2677   for (int i = 0; i < 10; ++i) {
2678 #pragma omp taskwait
2679     bar();
2680   }
2681 #pragma omp for
2682   for (int i = 0; i < 10; ++i) {
2683 #pragma omp flush
2684     bar();
2685   }
2686 #pragma omp for
2687   for (int i = 0; i < 10; ++i) {
2688 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
2689     bar();
2690   }
2691 #pragma omp for ordered
2692   for (int i = 0; i < 10; ++i) {
2693 #pragma omp ordered // OK
2694     bar();
2695   }
2696 #pragma omp for
2697   for (int i = 0; i < 10; ++i) {
2698 #pragma omp atomic
2699     ++a;
2700   }
2701 #pragma omp for
2702   for (int i = 0; i < 10; ++i) {
2703 #pragma omp target
2704     ++a;
2705   }
2706 #pragma omp for
2707   for (int i = 0; i < 10; ++i) {
2708 #pragma omp teams // expected-error {{region cannot be closely nested inside 'for' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
2709     ++a;
2710   }
2711 
2712 // FOR SIMD DIRECTIVE
2713 #pragma omp for simd
2714   for (int i = 0; i < 10; ++i) {
2715 #pragma omp for // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2716     for (int i = 0; i < 10; ++i)
2717       ;
2718   }
2719 #pragma omp for simd
2720   for (int i = 0; i < 10; ++i) {
2721 #pragma omp simd // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2722     for (int i = 0; i < 10; ++i)
2723       ;
2724   }
2725 #pragma omp for simd
2726   for (int i = 0; i < 10; ++i) {
2727 #pragma omp for simd // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2728     for (int i = 0; i < 10; ++i)
2729       ;
2730   }
2731 #pragma omp for simd
2732   for (int i = 0; i < 10; ++i) {
2733 #pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2734     for (int i = 0; i < 10; ++i)
2735       ;
2736   }
2737 #pragma omp for simd
2738   for (int i = 0; i < 10; ++i) {
2739 #pragma omp sections // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2740     {
2741       bar();
2742     }
2743   }
2744 #pragma omp for simd
2745   for (int i = 0; i < 10; ++i) {
2746 #pragma omp section // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2747     {
2748       bar();
2749     }
2750   }
2751 #pragma omp for simd
2752   for (int i = 0; i < 10; ++i) {
2753 #pragma omp single // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2754     bar();
2755 #pragma omp master // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2756     bar();
2757   }
2758 #pragma omp for simd
2759   for (int i = 0; i < 10; ++i) {
2760 #pragma omp single // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2761     bar();
2762 #pragma omp critical // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2763     bar();
2764   }
2765 #pragma omp for simd
2766   for (int i = 0; i < 10; ++i) {
2767 #pragma omp parallel for // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2768     for (int i = 0; i < 10; ++i)
2769       ;
2770   }
2771 #pragma omp for simd
2772   for (int i = 0; i < 10; ++i) {
2773 #pragma omp parallel for simd // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2774     for (int i = 0; i < 10; ++i)
2775       ;
2776   }
2777 #pragma omp for simd
2778   for (int i = 0; i < 10; ++i) {
2779 #pragma omp parallel sections // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2780     {
2781       bar();
2782     }
2783   }
2784 #pragma omp for simd
2785   for (int i = 0; i < 10; ++i) {
2786 #pragma omp task // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2787     {
2788       bar();
2789     }
2790   }
2791 #pragma omp for simd
2792   for (int i = 0; i < 10; ++i) {
2793 #pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2794     bar();
2795   }
2796 #pragma omp for simd
2797   for (int i = 0; i < 10; ++i) {
2798 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2799     bar();
2800   }
2801 #pragma omp for simd
2802   for (int i = 0; i < 10; ++i) {
2803 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2804     bar();
2805   }
2806 #pragma omp for simd
2807   for (int i = 0; i < 10; ++i) {
2808 #pragma omp flush // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2809     bar();
2810   }
2811 #pragma omp for simd
2812   for (int i = 0; i < 10; ++i) {
2813 #pragma omp ordered // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2814     bar();
2815   }
2816 #pragma omp for simd
2817   for (int i = 0; i < 10; ++i) {
2818 #pragma omp atomic // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2819     ++a;
2820   }
2821 #pragma omp for simd
2822   for (int i = 0; i < 10; ++i) {
2823 #pragma omp target // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2824     ++a;
2825   }
2826 #pragma omp for simd
2827   for (int i = 0; i < 10; ++i) {
2828 #pragma omp teams // expected-error {{OpenMP constructs may not be nested inside a simd region}}
2829     ++a;
2830   }
2831 
2832 // SECTIONS DIRECTIVE
2833 #pragma omp sections
2834   {
2835 #pragma omp for // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
2836     for (int i = 0; i < 10; ++i)
2837       ;
2838   }
2839 #pragma omp sections
2840   {
2841 #pragma omp simd
2842     for (int i = 0; i < 10; ++i)
2843       ;
2844   }
2845 #pragma omp sections
2846   {
2847 #pragma omp for simd // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}}
2848     for (int i = 0; i < 10; ++i)
2849       ;
2850   }
2851 #pragma omp sections
2852   {
2853 #pragma omp parallel
2854     for (int i = 0; i < 10; ++i)
2855       ;
2856   }
2857 #pragma omp sections
2858   {
2859 #pragma omp sections // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
2860     {
2861       bar();
2862     }
2863   }
2864 #pragma omp sections
2865   {
2866 #pragma omp section
2867     {
2868       bar();
2869     }
2870   }
2871 #pragma omp sections
2872   {
2873 #pragma omp critical
2874     bar();
2875 #pragma omp single // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
2876     bar();
2877 #pragma omp master // expected-error {{region cannot be closely nested inside 'sections' region}}
2878     bar();
2879   }
2880 #pragma omp sections
2881   {
2882 #pragma omp parallel
2883     {
2884 #pragma omp single // OK
2885       {
2886         bar();
2887       }
2888 #pragma omp for // OK
2889       for (int i = 0; i < 10; ++i)
2890         ;
2891 #pragma omp for simd // OK
2892       for (int i = 0; i < 10; ++i)
2893         ;
2894 #pragma omp sections // OK
2895       {
2896         bar();
2897       }
2898     }
2899   }
2900 #pragma omp sections
2901   {
2902 #pragma omp parallel for
2903     for (int i = 0; i < 10; ++i)
2904       ;
2905   }
2906 #pragma omp sections
2907   {
2908 #pragma omp parallel for simd
2909     for (int i = 0; i < 10; ++i)
2910       ;
2911   }
2912 #pragma omp sections
2913   {
2914 #pragma omp parallel sections
2915     {
2916       bar();
2917     }
2918   }
2919 #pragma omp sections
2920   {
2921 #pragma omp task
2922     {
2923       bar();
2924     }
2925   }
2926 #pragma omp sections
2927   {
2928 #pragma omp taskyield
2929   }
2930 #pragma omp sections
2931   {
2932 #pragma omp barrier // expected-error {{region cannot be closely nested inside 'sections' region}}
2933     bar();
2934   }
2935 #pragma omp sections
2936   {
2937 #pragma omp taskwait
2938   }
2939 #pragma omp sections
2940   {
2941 #pragma omp flush
2942   }
2943 #pragma omp sections
2944   {
2945 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
2946     bar();
2947   }
2948 #pragma omp sections
2949   {
2950 #pragma omp atomic
2951     ++a;
2952   }
2953 #pragma omp sections
2954   {
2955 #pragma omp target
2956     ++a;
2957   }
2958 #pragma omp sections
2959   {
2960 #pragma omp teams // expected-error {{region cannot be closely nested inside 'sections' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
2961     ++a;
2962   }
2963 
2964 // SECTION DIRECTIVE
2965 #pragma omp section // expected-error {{orphaned 'omp section' directives are prohibited, it must be closely nested to a sections region}}
2966   {
2967     bar();
2968   }
2969 #pragma omp sections
2970   {
2971 #pragma omp section
2972     {
2973 #pragma omp for // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
2974       for (int i = 0; i < 10; ++i)
2975         ;
2976     }
2977   }
2978 #pragma omp sections
2979   {
2980 #pragma omp section
2981     {
2982 #pragma omp simd
2983       for (int i = 0; i < 10; ++i)
2984         ;
2985     }
2986   }
2987 #pragma omp sections
2988   {
2989 #pragma omp section
2990     {
2991 #pragma omp for simd // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}}
2992       for (int i = 0; i < 10; ++i)
2993         ;
2994     }
2995   }
2996 #pragma omp sections
2997   {
2998 #pragma omp section
2999     {
3000 #pragma omp parallel
3001       for (int i = 0; i < 10; ++i)
3002         ;
3003     }
3004   }
3005 #pragma omp sections
3006   {
3007 #pragma omp section
3008     {
3009 #pragma omp sections // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
3010       {
3011         bar();
3012       }
3013     }
3014   }
3015 #pragma omp sections
3016   {
3017 #pragma omp section
3018     {
3019 #pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a section region}}
3020       {
3021         bar();
3022       }
3023     }
3024   }
3025 #pragma omp sections
3026   {
3027 #pragma omp section
3028     {
3029 #pragma omp single // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
3030       bar();
3031 #pragma omp master // expected-error {{region cannot be closely nested inside 'section' region}}
3032       bar();
3033 #pragma omp critical
3034       bar();
3035     }
3036   }
3037 #pragma omp sections
3038   {
3039 #pragma omp section
3040     {
3041 #pragma omp parallel
3042       {
3043 #pragma omp single // OK
3044         {
3045           bar();
3046         }
3047 #pragma omp for // OK
3048         for (int i = 0; i < 10; ++i)
3049           ;
3050 #pragma omp for simd // OK
3051         for (int i = 0; i < 10; ++i)
3052           ;
3053 #pragma omp sections // OK
3054         {
3055           bar();
3056         }
3057       }
3058     }
3059   }
3060 #pragma omp sections
3061   {
3062 #pragma omp section
3063     {
3064 #pragma omp parallel for
3065       for (int i = 0; i < 10; ++i)
3066         ;
3067     }
3068   }
3069 #pragma omp sections
3070   {
3071 #pragma omp section
3072     {
3073 #pragma omp parallel for simd
3074       for (int i = 0; i < 10; ++i)
3075         ;
3076     }
3077   }
3078 #pragma omp sections
3079   {
3080 #pragma omp section
3081     {
3082 #pragma omp parallel sections
3083       {
3084         bar();
3085       }
3086     }
3087   }
3088 #pragma omp sections
3089   {
3090 #pragma omp section
3091     {
3092 #pragma omp task
3093       {
3094         bar();
3095       }
3096     }
3097   }
3098 #pragma omp sections
3099   {
3100 #pragma omp section
3101     {
3102 #pragma omp taskyield
3103       bar();
3104     }
3105   }
3106 #pragma omp sections
3107   {
3108 #pragma omp section
3109     {
3110 #pragma omp barrier // expected-error {{region cannot be closely nested inside 'section' region}}
3111       bar();
3112     }
3113   }
3114 #pragma omp sections
3115   {
3116 #pragma omp section
3117     {
3118 #pragma omp taskwait
3119       bar();
3120     }
3121   }
3122 #pragma omp sections
3123   {
3124 #pragma omp section
3125     {
3126 #pragma omp flush
3127       bar();
3128     }
3129   }
3130 #pragma omp sections
3131   {
3132 #pragma omp section
3133     {
3134 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
3135       bar();
3136     }
3137   }
3138 #pragma omp sections
3139   {
3140 #pragma omp section
3141     {
3142 #pragma omp atomic
3143       ++a;
3144     }
3145   }
3146 #pragma omp sections
3147   {
3148 #pragma omp section
3149     {
3150 #pragma omp target
3151       ++a;
3152     }
3153   }
3154 #pragma omp sections
3155   {
3156 #pragma omp section
3157     {
3158 #pragma omp teams // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
3159       ++a;
3160     }
3161   }
3162 
3163 // SINGLE DIRECTIVE
3164 #pragma omp single
3165   {
3166 #pragma omp for // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
3167     for (int i = 0; i < 10; ++i)
3168       ;
3169   }
3170 #pragma omp single
3171   {
3172 #pragma omp simd
3173     for (int i = 0; i < 10; ++i)
3174       ;
3175   }
3176 #pragma omp single
3177   {
3178 #pragma omp for simd // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}}
3179     for (int i = 0; i < 10; ++i)
3180       ;
3181   }
3182 #pragma omp single
3183   {
3184 #pragma omp parallel
3185     for (int i = 0; i < 10; ++i)
3186       ;
3187   }
3188 #pragma omp single
3189   {
3190 #pragma omp single // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
3191     {
3192       bar();
3193     }
3194 #pragma omp master // expected-error {{region cannot be closely nested inside 'single' region}}
3195     bar();
3196 #pragma omp critical
3197     bar();
3198   }
3199 #pragma omp single
3200   {
3201 #pragma omp sections // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
3202     {
3203       bar();
3204     }
3205   }
3206 #pragma omp single
3207   {
3208 #pragma omp parallel
3209     {
3210 #pragma omp single // OK
3211       {
3212         bar();
3213       }
3214 #pragma omp for // OK
3215       for (int i = 0; i < 10; ++i)
3216         ;
3217 #pragma omp for simd // OK
3218       for (int i = 0; i < 10; ++i)
3219         ;
3220 #pragma omp sections // OK
3221       {
3222         bar();
3223       }
3224     }
3225   }
3226 #pragma omp single
3227   {
3228 #pragma omp parallel for
3229     for (int i = 0; i < 10; ++i)
3230       ;
3231   }
3232 #pragma omp single
3233   {
3234 #pragma omp parallel for simd
3235     for (int i = 0; i < 10; ++i)
3236       ;
3237   }
3238 #pragma omp single
3239   {
3240 #pragma omp parallel sections
3241     {
3242       bar();
3243     }
3244   }
3245 #pragma omp single
3246   {
3247 #pragma omp task
3248     {
3249       bar();
3250     }
3251   }
3252 #pragma omp single
3253   {
3254 #pragma omp taskyield
3255     bar();
3256   }
3257 #pragma omp single
3258   {
3259 #pragma omp barrier // expected-error {{region cannot be closely nested inside 'single' region}}
3260     bar();
3261   }
3262 #pragma omp single
3263   {
3264 #pragma omp taskwait
3265     bar();
3266   }
3267 #pragma omp single
3268   {
3269 #pragma omp flush
3270     bar();
3271   }
3272 #pragma omp single
3273   {
3274 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
3275     bar();
3276   }
3277 #pragma omp single
3278   {
3279 #pragma omp atomic
3280     ++a;
3281   }
3282 #pragma omp single
3283   {
3284 #pragma omp target
3285     ++a;
3286   }
3287 #pragma omp single
3288   {
3289 #pragma omp teams // expected-error {{region cannot be closely nested inside 'single' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
3290     ++a;
3291   }
3292 
3293 // MASTER DIRECTIVE
3294 #pragma omp master
3295   {
3296 #pragma omp for // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
3297     for (int i = 0; i < 10; ++i)
3298       ;
3299   }
3300 #pragma omp master
3301   {
3302 #pragma omp simd
3303     for (int i = 0; i < 10; ++i)
3304       ;
3305   }
3306 #pragma omp master
3307   {
3308 #pragma omp for simd // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}}
3309     for (int i = 0; i < 10; ++i)
3310       ;
3311   }
3312 #pragma omp master
3313   {
3314 #pragma omp parallel
3315     for (int i = 0; i < 10; ++i)
3316       ;
3317   }
3318 #pragma omp master
3319   {
3320 #pragma omp single // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
3321     {
3322       bar();
3323     }
3324   }
3325 #pragma omp master
3326   {
3327 #pragma omp master // OK, though second 'master' is redundant
3328     {
3329       bar();
3330     }
3331   }
3332 #pragma omp master
3333   {
3334 #pragma omp critical
3335     {
3336       bar();
3337     }
3338   }
3339 #pragma omp master
3340   {
3341 #pragma omp sections // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
3342     {
3343       bar();
3344     }
3345   }
3346 #pragma omp master
3347   {
3348 #pragma omp parallel
3349     {
3350 #pragma omp master // OK
3351       {
3352         bar();
3353       }
3354 #pragma omp for // OK
3355       for (int i = 0; i < 10; ++i)
3356         ;
3357 #pragma omp for simd // OK
3358       for (int i = 0; i < 10; ++i)
3359         ;
3360 #pragma omp sections // OK
3361       {
3362         bar();
3363       }
3364     }
3365   }
3366 #pragma omp master
3367   {
3368 #pragma omp parallel for
3369     for (int i = 0; i < 10; ++i)
3370       ;
3371   }
3372 #pragma omp master
3373   {
3374 #pragma omp parallel for simd
3375     for (int i = 0; i < 10; ++i)
3376       ;
3377   }
3378 #pragma omp master
3379   {
3380 #pragma omp parallel sections
3381     {
3382       bar();
3383     }
3384   }
3385 #pragma omp master
3386   {
3387 #pragma omp task
3388     {
3389       bar();
3390     }
3391   }
3392 #pragma omp master
3393   {
3394 #pragma omp taskyield
3395     bar();
3396   }
3397 #pragma omp master
3398   {
3399 #pragma omp barrier // expected-error {{region cannot be closely nested inside 'master' region}}
3400     bar();
3401   }
3402 #pragma omp master
3403   {
3404 #pragma omp taskwait
3405     bar();
3406   }
3407 #pragma omp master
3408   {
3409 #pragma omp flush
3410     bar();
3411   }
3412 #pragma omp master
3413   {
3414 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
3415     bar();
3416   }
3417 #pragma omp master
3418   {
3419 #pragma omp atomic
3420     ++a;
3421   }
3422 #pragma omp master
3423   {
3424 #pragma omp target
3425     ++a;
3426   }
3427 #pragma omp master
3428   {
3429 #pragma omp teams // expected-error {{region cannot be closely nested inside 'master' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
3430     ++a;
3431   }
3432 
3433 // CRITICAL DIRECTIVE
3434 #pragma omp critical
3435   {
3436 #pragma omp for // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
3437     for (int i = 0; i < 10; ++i)
3438       ;
3439   }
3440 #pragma omp critical
3441   {
3442 #pragma omp simd
3443     for (int i = 0; i < 10; ++i)
3444       ;
3445   }
3446 #pragma omp critical
3447   {
3448 #pragma omp for simd // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}}
3449     for (int i = 0; i < 10; ++i)
3450       ;
3451   }
3452 #pragma omp critical
3453   {
3454 #pragma omp parallel
3455     for (int i = 0; i < 10; ++i)
3456       ;
3457   }
3458 #pragma omp critical
3459   {
3460 #pragma omp single // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
3461     {
3462       bar();
3463     }
3464   }
3465 #pragma omp critical
3466   {
3467 #pragma omp master // OK, though second 'master' is redundant
3468     {
3469       bar();
3470     }
3471   }
3472 #pragma omp critical
3473   {
3474 #pragma omp critical
3475     {
3476       bar();
3477     }
3478   }
3479 #pragma omp critical
3480   {
3481 #pragma omp sections // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
3482     {
3483       bar();
3484     }
3485   }
3486 #pragma omp critical
3487   {
3488 #pragma omp parallel
3489     {
3490 #pragma omp master // OK
3491       {
3492         bar();
3493       }
3494 #pragma omp for // OK
3495       for (int i = 0; i < 10; ++i)
3496         ;
3497 #pragma omp for simd // OK
3498       for (int i = 0; i < 10; ++i)
3499         ;
3500 #pragma omp sections // OK
3501       {
3502         bar();
3503       }
3504     }
3505   }
3506 #pragma omp critical
3507   {
3508 #pragma omp parallel for
3509     for (int i = 0; i < 10; ++i)
3510       ;
3511   }
3512 #pragma omp critical
3513   {
3514 #pragma omp parallel for simd
3515     for (int i = 0; i < 10; ++i)
3516       ;
3517   }
3518 #pragma omp critical
3519   {
3520 #pragma omp parallel sections
3521     {
3522       bar();
3523     }
3524   }
3525 #pragma omp critical
3526   {
3527 #pragma omp task
3528     {
3529       bar();
3530     }
3531   }
3532 #pragma omp critical
3533   {
3534 #pragma omp taskyield
3535     bar();
3536   }
3537 #pragma omp critical
3538   {
3539 #pragma omp barrier // expected-error {{region cannot be closely nested inside 'critical' region}}
3540     bar();
3541   }
3542 #pragma omp critical
3543   {
3544 #pragma omp taskwait
3545     bar();
3546   }
3547 #pragma omp critical(Belka)
3548   {
3549 #pragma omp critical(Strelka)
3550     bar();
3551   }
3552 #pragma omp critical(Tuzik) // expected-note {{previous 'critical' region starts here}}
3553   {
3554 #pragma omp critical(grelka) // expected-note {{previous 'critical' region starts here}}
3555     {
3556 #pragma omp critical(Tuzik) // expected-error {{cannot nest 'critical' regions having the same name 'Tuzik'}}
3557       {
3558 #pragma omp parallel
3559 #pragma omp critical(grelka) // expected-error {{cannot nest 'critical' regions having the same name 'grelka'}}
3560         {
3561           bar();
3562         }
3563       }
3564     }
3565   }
3566 #pragma omp critical
3567   {
3568 #pragma omp flush
3569     bar();
3570   }
3571 #pragma omp critical
3572   {
3573 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
3574     bar();
3575   }
3576 #pragma omp critical
3577   {
3578 #pragma omp atomic
3579     ++a;
3580   }
3581 #pragma omp critical
3582   {
3583 #pragma omp target
3584     ++a;
3585   }
3586 #pragma omp critical
3587   {
3588 #pragma omp teams // expected-error {{region cannot be closely nested inside 'critical' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
3589     ++a;
3590   }
3591 
3592 // PARALLEL FOR DIRECTIVE
3593 #pragma omp parallel for
3594   for (int i = 0; i < 10; ++i) {
3595 #pragma omp for // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
3596     for (int i = 0; i < 10; ++i)
3597       ;
3598   }
3599 #pragma omp parallel for
3600   for (int i = 0; i < 10; ++i) {
3601 #pragma omp simd
3602     for (int i = 0; i < 10; ++i)
3603       ;
3604   }
3605 #pragma omp parallel for
3606   for (int i = 0; i < 10; ++i) {
3607 #pragma omp for simd // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}}
3608     for (int i = 0; i < 10; ++i)
3609       ;
3610   }
3611 
3612 #pragma omp parallel for
3613   for (int i = 0; i < 10; ++i) {
3614 #pragma omp parallel
3615     for (int i = 0; i < 10; ++i)
3616       ;
3617   }
3618 #pragma omp parallel for
3619   for (int i = 0; i < 10; ++i) {
3620 #pragma omp sections // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
3621     {
3622       bar();
3623     }
3624   }
3625 #pragma omp parallel for
3626   for (int i = 0; i < 10; ++i) {
3627 #pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a parallel for region}}
3628     {
3629       bar();
3630     }
3631   }
3632 #pragma omp parallel for
3633   for (int i = 0; i < 10; ++i) {
3634 #pragma omp single // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
3635     {
3636       bar();
3637     }
3638 #pragma omp master // expected-error {{region cannot be closely nested inside 'parallel for' region}}
3639     {
3640       bar();
3641     }
3642 #pragma omp critical
3643     {
3644       bar();
3645     }
3646   }
3647 #pragma omp parallel for
3648   for (int i = 0; i < 10; ++i) {
3649 #pragma omp parallel
3650     {
3651 #pragma omp single // OK
3652       {
3653         bar();
3654       }
3655 #pragma omp master // OK
3656       {
3657         bar();
3658       }
3659 #pragma omp critical // OK
3660       {
3661         bar();
3662       }
3663 #pragma omp for // OK
3664       for (int i = 0; i < 10; ++i)
3665         ;
3666 #pragma omp for simd // OK
3667       for (int i = 0; i < 10; ++i)
3668         ;
3669 #pragma omp sections // OK
3670       {
3671         bar();
3672       }
3673     }
3674   }
3675 #pragma omp parallel for
3676   for (int i = 0; i < 10; ++i) {
3677 #pragma omp parallel for
3678     for (int i = 0; i < 10; ++i)
3679       ;
3680   }
3681 #pragma omp parallel for
3682   for (int i = 0; i < 10; ++i) {
3683 #pragma omp parallel for simd
3684     for (int i = 0; i < 10; ++i)
3685       ;
3686   }
3687 #pragma omp parallel for
3688   for (int i = 0; i < 10; ++i) {
3689 #pragma omp parallel sections
3690     {
3691       bar();
3692     }
3693   }
3694 #pragma omp parallel for
3695   for (int i = 0; i < 10; ++i) {
3696 #pragma omp task
3697     {
3698       bar();
3699     }
3700   }
3701 #pragma omp parallel for
3702   for (int i = 0; i < 10; ++i) {
3703 #pragma omp taskyield
3704     bar();
3705   }
3706 #pragma omp parallel for
3707   for (int i = 0; i < 10; ++i) {
3708 #pragma omp barrier // expected-error {{region cannot be closely nested inside 'parallel for' region}}
3709     bar();
3710   }
3711 #pragma omp parallel for
3712   for (int i = 0; i < 10; ++i) {
3713 #pragma omp taskwait
3714     bar();
3715   }
3716 #pragma omp parallel for
3717   for (int i = 0; i < 10; ++i) {
3718 #pragma omp flush
3719     bar();
3720   }
3721 #pragma omp parallel for
3722   for (int i = 0; i < 10; ++i) {
3723 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
3724     bar();
3725   }
3726 #pragma omp parallel for ordered
3727   for (int i = 0; i < 10; ++i) {
3728 #pragma omp ordered // OK
3729     bar();
3730   }
3731 #pragma omp parallel for
3732   for (int i = 0; i < 10; ++i) {
3733 #pragma omp atomic
3734     ++a;
3735   }
3736 #pragma omp parallel for
3737   for (int i = 0; i < 10; ++i) {
3738 #pragma omp target
3739     ++a;
3740   }
3741 #pragma omp parallel for
3742   for (int i = 0; i < 10; ++i) {
3743 #pragma omp teams // expected-error {{region cannot be closely nested inside 'parallel for' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
3744     ++a;
3745   }
3746 
3747 // PARALLEL FOR SIMD DIRECTIVE
3748 #pragma omp parallel for simd
3749   for (int i = 0; i < 10; ++i) {
3750 #pragma omp for // expected-error {{OpenMP constructs may not be nested inside a simd region}}
3751     for (int i = 0; i < 10; ++i)
3752       ;
3753   }
3754 #pragma omp parallel for simd
3755   for (int i = 0; i < 10; ++i) {
3756 #pragma omp simd// expected-error {{OpenMP constructs may not be nested inside a simd region}}
3757     for (int i = 0; i < 10; ++i)
3758       ;
3759   }
3760 #pragma omp parallel for simd
3761   for (int i = 0; i < 10; ++i) {
3762 #pragma omp for simd // expected-error {{OpenMP constructs may not be nested inside a simd region}}
3763     for (int i = 0; i < 10; ++i)
3764       ;
3765   }
3766 #pragma omp parallel for simd
3767   for (int i = 0; i < 10; ++i) {
3768 #pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}}
3769     for (int i = 0; i < 10; ++i)
3770       ;
3771   }
3772 #pragma omp parallel for simd
3773   for (int i = 0; i < 10; ++i) {
3774 #pragma omp sections // expected-error {{OpenMP constructs may not be nested inside a simd region}}
3775     {
3776       bar();
3777     }
3778   }
3779 #pragma omp parallel for simd
3780   for (int i = 0; i < 10; ++i) {
3781 #pragma omp section // expected-error {{OpenMP constructs may not be nested inside a simd region}}
3782     {
3783       bar();
3784     }
3785   }
3786 #pragma omp parallel for simd
3787   for (int i = 0; i < 10; ++i) {
3788 #pragma omp single // expected-error {{OpenMP constructs may not be nested inside a simd region}}
3789     {
3790       bar();
3791     }
3792   }
3793 
3794 #pragma omp parallel for simd
3795   for (int i = 0; i < 10; ++i) {
3796 #pragma omp master // expected-error {{OpenMP constructs may not be nested inside a simd region}}
3797     {
3798       bar();
3799     }
3800   }
3801 
3802 #pragma omp parallel for simd
3803   for (int i = 0; i < 10; ++i) {
3804 #pragma omp critical // expected-error {{OpenMP constructs may not be nested inside a simd region}}
3805     {
3806       bar();
3807     }
3808   }
3809 
3810 #pragma omp parallel for simd
3811   for (int i = 0; i < 10; ++i) {
3812 #pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside a simd region}}
3813     {
3814 #pragma omp single
3815       {
3816         bar();
3817       }
3818 #pragma omp for
3819       for (int i = 0; i < 10; ++i)
3820         ;
3821 #pragma omp for simd
3822       for (int i = 0; i < 10; ++i)
3823         ;
3824 #pragma omp sections
3825       {
3826         bar();
3827       }
3828     }
3829   }
3830 #pragma omp parallel for simd
3831   for (int i = 0; i < 10; ++i) {
3832 #pragma omp parallel for // expected-error {{OpenMP constructs may not be nested inside a simd region}}
3833     for (int i = 0; i < 10; ++i)
3834       ;
3835   }
3836 #pragma omp parallel for simd
3837   for (int i = 0; i < 10; ++i) {
3838 #pragma omp parallel for simd// expected-error {{OpenMP constructs may not be nested inside a simd region}}
3839     for (int i = 0; i < 10; ++i)
3840       ;
3841   }
3842 #pragma omp parallel for simd
3843   for (int i = 0; i < 10; ++i) {
3844 #pragma omp parallel sections // expected-error {{OpenMP constructs may not be nested inside a simd region}}
3845     {
3846       bar();
3847     }
3848   }
3849 #pragma omp parallel for simd
3850   for (int i = 0; i < 10; ++i) {
3851 #pragma omp task // expected-error {{OpenMP constructs may not be nested inside a simd region}}
3852     {
3853       bar();
3854     }
3855   }
3856 #pragma omp parallel for simd
3857   for (int i = 0; i < 10; ++i) {
3858 #pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside a simd region}}
3859     bar();
3860   }
3861 #pragma omp parallel for simd
3862   for (int i = 0; i < 10; ++i) {
3863 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside a simd region}}
3864     bar();
3865   }
3866 #pragma omp parallel for simd
3867   for (int i = 0; i < 10; ++i) {
3868 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside a simd region}}
3869     bar();
3870   }
3871 #pragma omp parallel for simd
3872   for (int i = 0; i < 10; ++i) {
3873 #pragma omp flush // expected-error {{OpenMP constructs may not be nested inside a simd region}}
3874     bar();
3875   }
3876 #pragma omp parallel for simd
3877   for (int i = 0; i < 10; ++i) {
3878 #pragma omp ordered // expected-error {{OpenMP constructs may not be nested inside a simd region}}
3879     bar();
3880   }
3881 #pragma omp parallel for simd
3882   for (int i = 0; i < 10; ++i) {
3883 #pragma omp ordered // expected-error {{OpenMP constructs may not be nested inside a simd region}}
3884     bar();
3885   }
3886 #pragma omp parallel for simd
3887   for (int i = 0; i < 10; ++i) {
3888 #pragma omp atomic // expected-error {{OpenMP constructs may not be nested inside a simd region}}
3889     ++a;
3890   }
3891 #pragma omp parallel for simd
3892   for (int i = 0; i < 10; ++i) {
3893 #pragma omp target // expected-error {{OpenMP constructs may not be nested inside a simd region}}
3894     ++a;
3895   }
3896 #pragma omp parallel for simd
3897   for (int i = 0; i < 10; ++i) {
3898 #pragma omp teams // expected-error {{OpenMP constructs may not be nested inside a simd region}}
3899     ++a;
3900   }
3901 
3902 // PARALLEL SECTIONS DIRECTIVE
3903 #pragma omp parallel sections
3904   {
3905 #pragma omp for // expected-error {{region cannot be closely nested inside 'parallel sections' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
3906     for (int i = 0; i < 10; ++i)
3907       ;
3908   }
3909 #pragma omp parallel sections
3910   {
3911 #pragma omp simd
3912     for (int i = 0; i < 10; ++i)
3913       ;
3914   }
3915 #pragma omp parallel sections
3916   {
3917 #pragma omp for simd // expected-error {{region cannot be closely nested inside 'parallel sections' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}}
3918     for (int i = 0; i < 10; ++i)
3919       ;
3920   }
3921 #pragma omp parallel sections
3922   {
3923 #pragma omp parallel
3924     for (int i = 0; i < 10; ++i)
3925       ;
3926   }
3927 #pragma omp parallel sections
3928   {
3929 #pragma omp sections // expected-error {{region cannot be closely nested inside 'parallel sections' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
3930     {
3931       bar();
3932     }
3933   }
3934 #pragma omp parallel sections
3935   {
3936 #pragma omp section
3937     {
3938       bar();
3939     }
3940   }
3941 #pragma omp parallel sections
3942   {
3943 #pragma omp section
3944     {
3945 #pragma omp single // expected-error {{region cannot be closely nested inside 'section' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
3946       bar();
3947 #pragma omp master // expected-error {{region cannot be closely nested inside 'section' region}}
3948       bar();
3949 #pragma omp critical
3950       bar();
3951     }
3952   }
3953 #pragma omp parallel sections
3954   {
3955 #pragma omp parallel
3956     {
3957 #pragma omp single // OK
3958       {
3959         bar();
3960       }
3961 #pragma omp master // OK
3962       {
3963         bar();
3964       }
3965 #pragma omp critical // OK
3966       {
3967         bar();
3968       }
3969 #pragma omp for // OK
3970       for (int i = 0; i < 10; ++i)
3971         ;
3972 #pragma omp for simd // OK
3973       for (int i = 0; i < 10; ++i)
3974         ;
3975 #pragma omp sections // OK
3976       {
3977         bar();
3978       }
3979     }
3980   }
3981 #pragma omp parallel sections
3982   {
3983 #pragma omp parallel for
3984     for (int i = 0; i < 10; ++i)
3985       ;
3986   }
3987 #pragma omp parallel sections
3988   {
3989 #pragma omp parallel for simd
3990     for (int i = 0; i < 10; ++i)
3991       ;
3992   }
3993 #pragma omp parallel sections
3994   {
3995 #pragma omp parallel sections
3996     {
3997       bar();
3998     }
3999   }
4000 #pragma omp parallel sections
4001   {
4002 #pragma omp task
4003     {
4004       bar();
4005     }
4006   }
4007 #pragma omp parallel sections
4008   {
4009 #pragma omp taskyield
4010   }
4011 #pragma omp parallel sections
4012   {
4013 #pragma omp barrier // expected-error {{region cannot be closely nested inside 'parallel sections' region}}
4014   }
4015 #pragma omp parallel sections
4016   {
4017 #pragma omp taskwait
4018   }
4019 #pragma omp parallel sections
4020   {
4021 #pragma omp flush
4022   }
4023 #pragma omp parallel sections
4024   {
4025 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'parallel sections' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
4026     bar();
4027   }
4028 #pragma omp parallel sections
4029   {
4030 #pragma omp atomic
4031     ++a;
4032   }
4033 #pragma omp parallel sections
4034   {
4035 #pragma omp target
4036     ++a;
4037   }
4038 #pragma omp parallel sections
4039   {
4040 #pragma omp teams // expected-error {{region cannot be closely nested inside 'parallel sections' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
4041     ++a;
4042   }
4043 
4044 // TASK DIRECTIVE
4045 #pragma omp task
4046 #pragma omp for // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
4047   for (int i = 0; i < 10; ++i)
4048     ;
4049 #pragma omp task
4050 #pragma omp simd
4051   for (int i = 0; i < 10; ++i)
4052     ;
4053 #pragma omp task
4054 #pragma omp for simd // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}}
4055   for (int i = 0; i < 10; ++i)
4056     ;
4057 #pragma omp task
4058 #pragma omp sections // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
4059   {
4060     bar();
4061   }
4062 #pragma omp task
4063 #pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a task region}}
4064   {
4065     bar();
4066   }
4067 #pragma omp task
4068 #pragma omp single // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
4069   bar();
4070 #pragma omp task
4071 #pragma omp master // expected-error {{region cannot be closely nested inside 'task' region}}
4072   bar();
4073 #pragma omp task
4074 #pragma omp critical
4075   bar();
4076 #pragma omp task
4077 #pragma omp parallel for
4078   for (int i = 0; i < 10; ++i)
4079     ;
4080 #pragma omp task
4081 #pragma omp parallel for simd
4082   for (int i = 0; i < 10; ++i)
4083     ;
4084 #pragma omp task
4085 #pragma omp parallel sections
4086   {
4087     bar();
4088   }
4089 #pragma omp task
4090 #pragma omp task
4091   {
4092     bar();
4093   }
4094 #pragma omp task
4095   {
4096 #pragma omp taskyield
4097     bar();
4098   }
4099 #pragma omp task
4100   {
4101 #pragma omp barrier // expected-error {{region cannot be closely nested inside 'task' region}}
4102     bar();
4103   }
4104 #pragma omp task
4105   {
4106 #pragma omp taskwait
4107     bar();
4108   }
4109 #pragma omp task
4110   {
4111 #pragma omp flush
4112     bar();
4113   }
4114 #pragma omp task
4115   {
4116 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
4117     bar();
4118   }
4119 #pragma omp task
4120   {
4121 #pragma omp atomic
4122     ++a;
4123   }
4124 #pragma omp task
4125   {
4126 #pragma omp target
4127     ++a;
4128   }
4129 #pragma omp task
4130   {
4131 #pragma omp teams // expected-error {{region cannot be closely nested inside 'task' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
4132     ++a;
4133   }
4134 
4135 // ATOMIC DIRECTIVE
4136 #pragma omp atomic
4137   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
4138   {
4139 #pragma omp for // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
4140     for (int i = 0; i < 10; ++i)
4141       ;
4142   }
4143 #pragma omp atomic
4144   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
4145   {
4146 #pragma omp simd // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
4147     for (int i = 0; i < 10; ++i)
4148       ;
4149   }
4150 #pragma omp atomic
4151   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
4152   {
4153 #pragma omp for simd // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
4154     for (int i = 0; i < 10; ++i)
4155       ;
4156   }
4157 #pragma omp atomic
4158   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
4159   {
4160 #pragma omp parallel // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
4161     for (int i = 0; i < 10; ++i)
4162       ;
4163   }
4164 #pragma omp atomic
4165   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
4166   {
4167 #pragma omp sections // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
4168     {
4169       bar();
4170     }
4171   }
4172 #pragma omp atomic
4173   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
4174   {
4175 #pragma omp section // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
4176     {
4177       bar();
4178     }
4179   }
4180 #pragma omp atomic
4181   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
4182   {
4183 #pragma omp single // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
4184     {
4185       bar();
4186     }
4187   }
4188 #pragma omp atomic
4189   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
4190   {
4191 #pragma omp master // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
4192     {
4193       bar();
4194     }
4195   }
4196 #pragma omp atomic
4197   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
4198   {
4199 #pragma omp critical // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
4200     {
4201       bar();
4202     }
4203   }
4204 #pragma omp atomic
4205   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
4206   {
4207 #pragma omp parallel for // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
4208     for (int i = 0; i < 10; ++i)
4209       ;
4210   }
4211 #pragma omp atomic
4212   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
4213   {
4214 #pragma omp parallel for simd // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
4215     for (int i = 0; i < 10; ++i)
4216       ;
4217   }
4218 #pragma omp atomic
4219   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
4220   {
4221 #pragma omp parallel sections // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
4222     {
4223       bar();
4224     }
4225   }
4226 #pragma omp atomic
4227   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
4228   {
4229 #pragma omp task // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
4230     {
4231       bar();
4232     }
4233   }
4234 #pragma omp atomic
4235   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
4236   {
4237 #pragma omp taskyield // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
4238     bar();
4239   }
4240 #pragma omp atomic
4241   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
4242   {
4243 #pragma omp barrier // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
4244     bar();
4245   }
4246 #pragma omp atomic
4247   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
4248   {
4249 #pragma omp taskwait // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
4250     bar();
4251   }
4252 #pragma omp atomic
4253   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
4254   {
4255 #pragma omp flush // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
4256     bar();
4257   }
4258 #pragma omp atomic
4259   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
4260   {
4261 #pragma omp ordered // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
4262     bar();
4263   }
4264 #pragma omp atomic
4265   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
4266   {
4267 #pragma omp atomic // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
4268     ++a;
4269   }
4270 #pragma omp atomic
4271   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
4272   {
4273 #pragma omp target // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
4274     ++a;
4275   }
4276 #pragma omp atomic
4277   // expected-error@+1 {{the statement for 'atomic' must be an expression statement of form '++x;', '--x;', 'x++;', 'x--;', 'x binop= expr;', 'x = x binop expr' or 'x = expr binop x', where x is an l-value expression with scalar type}}
4278   {
4279 #pragma omp teams // expected-error {{OpenMP constructs may not be nested inside an atomic region}}
4280     ++a;
4281   }
4282 
4283 // TARGET DIRECTIVE
4284 #pragma omp target
4285 #pragma omp parallel
4286   bar();
4287 #pragma omp target
4288 #pragma omp for
4289   for (int i = 0; i < 10; ++i)
4290     ;
4291 #pragma omp target
4292 #pragma omp simd
4293   for (int i = 0; i < 10; ++i)
4294     ;
4295 #pragma omp target
4296 #pragma omp for simd
4297   for (int i = 0; i < 10; ++i)
4298     ;
4299 #pragma omp target
4300 #pragma omp sections
4301   {
4302     bar();
4303   }
4304 #pragma omp target
4305 #pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a target region}}
4306   {
4307     bar();
4308   }
4309 #pragma omp target
4310 #pragma omp single
4311   bar();
4312 
4313 #pragma omp target
4314 #pragma omp master
4315   {
4316     bar();
4317   }
4318 #pragma omp target
4319 #pragma omp critical
4320   {
4321     bar();
4322   }
4323 #pragma omp target
4324 #pragma omp parallel for
4325   for (int i = 0; i < 10; ++i)
4326     ;
4327 #pragma omp target
4328 #pragma omp parallel for simd
4329   for (int i = 0; i < 10; ++i)
4330     ;
4331 #pragma omp target
4332 #pragma omp parallel sections
4333   {
4334     bar();
4335   }
4336 #pragma omp target
4337 #pragma omp task
4338   {
4339     bar();
4340   }
4341 #pragma omp target
4342   {
4343 #pragma omp taskyield
4344     bar();
4345   }
4346 #pragma omp target
4347   {
4348 #pragma omp barrier
4349     bar();
4350   }
4351 #pragma omp target
4352   {
4353 #pragma omp taskwait
4354     bar();
4355   }
4356 #pragma omp target
4357   {
4358 #pragma omp flush
4359     bar();
4360   }
4361 #pragma omp target
4362   {
4363 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'target' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
4364     bar();
4365   }
4366 #pragma omp target
4367   {
4368 #pragma omp atomic
4369     ++a;
4370   }
4371 #pragma omp target
4372   {
4373 #pragma omp target
4374     ++a;
4375   }
4376 #pragma omp target
4377   {
4378 #pragma omp teams
4379     ++a;
4380   }
4381 #pragma omp target // expected-error {{target construct with nested teams region contains statements outside of the teams construct}}
4382   {
4383     ++a;          // expected-note {{statement outside teams construct here}}
4384 #pragma omp teams // expected-note {{nested teams construct here}}
4385     ++a;
4386   }
4387 
4388 // TEAMS DIRECTIVE
4389 #pragma omp target
4390 #pragma omp teams
4391 #pragma omp parallel
4392   bar();
4393 #pragma omp target
4394 #pragma omp teams
4395 #pragma omp for // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp for' directive into a parallel region?}}
4396   for (int i = 0; i < 10; ++i)
4397     ;
4398 #pragma omp target
4399 #pragma omp teams
4400 #pragma omp simd // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp simd' directive into a parallel region?}}
4401   for (int i = 0; i < 10; ++i)
4402     ;
4403 #pragma omp target
4404 #pragma omp teams
4405 #pragma omp for simd // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp for simd' directive into a parallel region?}}
4406   for (int i = 0; i < 10; ++i)
4407     ;
4408 #pragma omp target
4409 #pragma omp teams
4410 #pragma omp sections // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp sections' directive into a parallel region?}}
4411   {
4412     bar();
4413   }
4414 #pragma omp target
4415 #pragma omp teams
4416 #pragma omp section // expected-error {{'omp section' directive must be closely nested to a sections region, not a teams region}}
4417   {
4418     bar();
4419   }
4420 #pragma omp target
4421 #pragma omp teams
4422 #pragma omp single // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp single' directive into a parallel region?}}
4423   bar();
4424 
4425 #pragma omp target
4426 #pragma omp teams
4427 #pragma omp master // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp master' directive into a parallel region?}}
4428   {
4429     bar();
4430   }
4431 #pragma omp target
4432 #pragma omp teams
4433 #pragma omp critical // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp critical' directive into a parallel region?}}
4434   {
4435     bar();
4436   }
4437 #pragma omp target
4438 #pragma omp teams
4439 #pragma omp parallel for
4440   for (int i = 0; i < 10; ++i)
4441     ;
4442 #pragma omp target
4443 #pragma omp teams
4444 #pragma omp parallel for simd
4445   for (int i = 0; i < 10; ++i)
4446     ;
4447 #pragma omp target
4448 #pragma omp teams
4449 #pragma omp parallel sections
4450   {
4451     bar();
4452   }
4453 #pragma omp target
4454 #pragma omp teams
4455 #pragma omp task // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp task' directive into a parallel region?}}
4456   {
4457     bar();
4458   }
4459 #pragma omp target
4460 #pragma omp teams
4461   {
4462 #pragma omp taskyield // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp taskyield' directive into a parallel region?}}
4463     bar();
4464   }
4465 #pragma omp target
4466 #pragma omp teams
4467   {
4468 #pragma omp barrier // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp barrier' directive into a parallel region?}}
4469     bar();
4470   }
4471 #pragma omp target
4472 #pragma omp teams
4473   {
4474 #pragma omp taskwait // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp taskwait' directive into a parallel region?}}
4475     bar();
4476   }
4477 #pragma omp target
4478 #pragma omp teams
4479   {
4480 #pragma omp flush // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp flush' directive into a parallel region?}}
4481     bar();
4482   }
4483 #pragma omp target
4484 #pragma omp teams
4485   {
4486 #pragma omp ordered // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp ordered' directive into a for or a parallel for region with 'ordered' clause?}}
4487     bar();
4488   }
4489 #pragma omp target
4490 #pragma omp teams
4491   {
4492 #pragma omp atomic // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp atomic' directive into a parallel region?}}
4493     ++a;
4494   }
4495 #pragma omp target
4496 #pragma omp teams
4497   {
4498 #pragma omp target // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp target' directive into a parallel region?}}
4499     ++a;
4500   }
4501 #pragma omp target
4502 #pragma omp teams
4503   {
4504 #pragma omp teams // expected-error {{region cannot be closely nested inside 'teams' region; perhaps you forget to enclose 'omp teams' directive into a target region?}}
4505     ++a;
4506   }
4507   return foo<int>();
4508 }
4509 
4510