1 // RUN: %clang_cc1 -fsyntax-only -fopenmp=libiomp5 -verify %s
2
3 void bar();
4
5 template <class T>
foo()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
foo()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