1 //===--- OpenMPKinds.cpp - Token Kinds Support ----------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 /// \brief This file implements the OpenMP enum and support functions.
12 //===----------------------------------------------------------------------===//
14 #include "clang/Basic/OpenMPKinds.h"
15 #include "clang/Basic/IdentifierTable.h"
16 #include "llvm/ADT/StringRef.h"
17 #include "llvm/ADT/StringSwitch.h"
18 #include "llvm/Support/ErrorHandling.h"
21 using namespace clang;
23 OpenMPDirectiveKind clang::getOpenMPDirectiveKind(StringRef Str) {
24 return llvm::StringSwitch<OpenMPDirectiveKind>(Str)
25 #define OPENMP_DIRECTIVE(Name) .Case(#Name, OMPD_##Name)
26 #define OPENMP_DIRECTIVE_EXT(Name, Str) .Case(Str, OMPD_##Name)
27 #include "clang/Basic/OpenMPKinds.def"
28 .Default(OMPD_unknown);
31 const char *clang::getOpenMPDirectiveName(OpenMPDirectiveKind Kind) {
32 assert(Kind <= OMPD_unknown);
36 #define OPENMP_DIRECTIVE(Name) \
39 #define OPENMP_DIRECTIVE_EXT(Name, Str) \
42 #include "clang/Basic/OpenMPKinds.def"
45 llvm_unreachable("Invalid OpenMP directive kind");
48 OpenMPClauseKind clang::getOpenMPClauseKind(StringRef Str) {
49 // 'flush' clause cannot be specified explicitly, because this is an implicit
50 // clause for 'flush' directive. If the 'flush' clause is explicitly specified
51 // the Parser should generate a warning about extra tokens at the end of the
55 return llvm::StringSwitch<OpenMPClauseKind>(Str)
56 #define OPENMP_CLAUSE(Name, Class) .Case(#Name, OMPC_##Name)
57 #include "clang/Basic/OpenMPKinds.def"
58 .Case("uniform", OMPC_uniform)
59 .Default(OMPC_unknown);
62 const char *clang::getOpenMPClauseName(OpenMPClauseKind Kind) {
63 assert(Kind <= OMPC_unknown);
67 #define OPENMP_CLAUSE(Name, Class) \
70 #include "clang/Basic/OpenMPKinds.def"
73 case OMPC_threadprivate:
74 return "threadprivate or thread local";
76 llvm_unreachable("Invalid OpenMP clause kind");
79 unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind,
83 return llvm::StringSwitch<OpenMPDefaultClauseKind>(Str)
84 #define OPENMP_DEFAULT_KIND(Name) .Case(#Name, OMPC_DEFAULT_##Name)
85 #include "clang/Basic/OpenMPKinds.def"
86 .Default(OMPC_DEFAULT_unknown);
88 return llvm::StringSwitch<OpenMPProcBindClauseKind>(Str)
89 #define OPENMP_PROC_BIND_KIND(Name) .Case(#Name, OMPC_PROC_BIND_##Name)
90 #include "clang/Basic/OpenMPKinds.def"
91 .Default(OMPC_PROC_BIND_unknown);
93 return llvm::StringSwitch<unsigned>(Str)
94 #define OPENMP_SCHEDULE_KIND(Name) \
95 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_##Name))
96 #define OPENMP_SCHEDULE_MODIFIER(Name) \
97 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_MODIFIER_##Name))
98 #include "clang/Basic/OpenMPKinds.def"
99 .Default(OMPC_SCHEDULE_unknown);
101 return llvm::StringSwitch<OpenMPDependClauseKind>(Str)
102 #define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name)
103 #include "clang/Basic/OpenMPKinds.def"
104 .Default(OMPC_DEPEND_unknown);
106 return llvm::StringSwitch<OpenMPLinearClauseKind>(Str)
107 #define OPENMP_LINEAR_KIND(Name) .Case(#Name, OMPC_LINEAR_##Name)
108 #include "clang/Basic/OpenMPKinds.def"
109 .Default(OMPC_LINEAR_unknown);
111 return llvm::StringSwitch<OpenMPMapClauseKind>(Str)
112 #define OPENMP_MAP_KIND(Name) .Case(#Name, OMPC_MAP_##Name)
113 #include "clang/Basic/OpenMPKinds.def"
114 .Default(OMPC_MAP_unknown);
115 case OMPC_dist_schedule:
116 return llvm::StringSwitch<OpenMPDistScheduleClauseKind>(Str)
117 #define OPENMP_DIST_SCHEDULE_KIND(Name) .Case(#Name, OMPC_DIST_SCHEDULE_##Name)
118 #include "clang/Basic/OpenMPKinds.def"
119 .Default(OMPC_DIST_SCHEDULE_unknown);
120 case OMPC_defaultmap:
121 return llvm::StringSwitch<unsigned>(Str)
122 #define OPENMP_DEFAULTMAP_KIND(Name) \
123 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_##Name))
124 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \
125 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_MODIFIER_##Name))
126 #include "clang/Basic/OpenMPKinds.def"
127 .Default(OMPC_DEFAULTMAP_unknown);
129 case OMPC_threadprivate:
132 case OMPC_num_threads:
137 case OMPC_firstprivate:
138 case OMPC_lastprivate:
141 case OMPC_task_reduction:
144 case OMPC_copyprivate:
159 case OMPC_thread_limit:
168 case OMPC_use_device_ptr:
169 case OMPC_is_device_ptr:
172 llvm_unreachable("Invalid OpenMP simple clause kind");
175 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
180 case OMPC_DEFAULT_unknown:
182 #define OPENMP_DEFAULT_KIND(Name) \
183 case OMPC_DEFAULT_##Name: \
185 #include "clang/Basic/OpenMPKinds.def"
187 llvm_unreachable("Invalid OpenMP 'default' clause type");
190 case OMPC_PROC_BIND_unknown:
192 #define OPENMP_PROC_BIND_KIND(Name) \
193 case OMPC_PROC_BIND_##Name: \
195 #include "clang/Basic/OpenMPKinds.def"
197 llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
200 case OMPC_SCHEDULE_unknown:
201 case OMPC_SCHEDULE_MODIFIER_last:
203 #define OPENMP_SCHEDULE_KIND(Name) \
204 case OMPC_SCHEDULE_##Name: \
206 #define OPENMP_SCHEDULE_MODIFIER(Name) \
207 case OMPC_SCHEDULE_MODIFIER_##Name: \
209 #include "clang/Basic/OpenMPKinds.def"
211 llvm_unreachable("Invalid OpenMP 'schedule' clause type");
214 case OMPC_DEPEND_unknown:
216 #define OPENMP_DEPEND_KIND(Name) \
217 case OMPC_DEPEND_##Name: \
219 #include "clang/Basic/OpenMPKinds.def"
221 llvm_unreachable("Invalid OpenMP 'depend' clause type");
224 case OMPC_LINEAR_unknown:
226 #define OPENMP_LINEAR_KIND(Name) \
227 case OMPC_LINEAR_##Name: \
229 #include "clang/Basic/OpenMPKinds.def"
231 llvm_unreachable("Invalid OpenMP 'linear' clause type");
234 case OMPC_MAP_unknown:
236 #define OPENMP_MAP_KIND(Name) \
237 case OMPC_MAP_##Name: \
239 #include "clang/Basic/OpenMPKinds.def"
243 llvm_unreachable("Invalid OpenMP 'map' clause type");
244 case OMPC_dist_schedule:
246 case OMPC_DIST_SCHEDULE_unknown:
248 #define OPENMP_DIST_SCHEDULE_KIND(Name) \
249 case OMPC_DIST_SCHEDULE_##Name: \
251 #include "clang/Basic/OpenMPKinds.def"
253 llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type");
254 case OMPC_defaultmap:
256 case OMPC_DEFAULTMAP_unknown:
257 case OMPC_DEFAULTMAP_MODIFIER_last:
259 #define OPENMP_DEFAULTMAP_KIND(Name) \
260 case OMPC_DEFAULTMAP_##Name: \
262 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \
263 case OMPC_DEFAULTMAP_MODIFIER_##Name: \
265 #include "clang/Basic/OpenMPKinds.def"
267 llvm_unreachable("Invalid OpenMP 'schedule' clause type");
269 case OMPC_threadprivate:
272 case OMPC_num_threads:
277 case OMPC_firstprivate:
278 case OMPC_lastprivate:
281 case OMPC_task_reduction:
284 case OMPC_copyprivate:
299 case OMPC_thread_limit:
308 case OMPC_use_device_ptr:
309 case OMPC_is_device_ptr:
312 llvm_unreachable("Invalid OpenMP simple clause kind");
315 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
316 OpenMPClauseKind CKind) {
317 assert(DKind <= OMPD_unknown);
318 assert(CKind <= OMPC_unknown);
322 #define OPENMP_PARALLEL_CLAUSE(Name) \
325 #include "clang/Basic/OpenMPKinds.def"
332 #define OPENMP_SIMD_CLAUSE(Name) \
335 #include "clang/Basic/OpenMPKinds.def"
342 #define OPENMP_FOR_CLAUSE(Name) \
345 #include "clang/Basic/OpenMPKinds.def"
352 #define OPENMP_FOR_SIMD_CLAUSE(Name) \
355 #include "clang/Basic/OpenMPKinds.def"
362 #define OPENMP_SECTIONS_CLAUSE(Name) \
365 #include "clang/Basic/OpenMPKinds.def"
372 #define OPENMP_SINGLE_CLAUSE(Name) \
375 #include "clang/Basic/OpenMPKinds.def"
380 case OMPD_parallel_for:
382 #define OPENMP_PARALLEL_FOR_CLAUSE(Name) \
385 #include "clang/Basic/OpenMPKinds.def"
390 case OMPD_parallel_for_simd:
392 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name) \
395 #include "clang/Basic/OpenMPKinds.def"
400 case OMPD_parallel_sections:
402 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name) \
405 #include "clang/Basic/OpenMPKinds.def"
412 #define OPENMP_TASK_CLAUSE(Name) \
415 #include "clang/Basic/OpenMPKinds.def"
421 return CKind == OMPC_flush;
425 #define OPENMP_ATOMIC_CLAUSE(Name) \
428 #include "clang/Basic/OpenMPKinds.def"
435 #define OPENMP_TARGET_CLAUSE(Name) \
438 #include "clang/Basic/OpenMPKinds.def"
443 case OMPD_target_data:
445 #define OPENMP_TARGET_DATA_CLAUSE(Name) \
448 #include "clang/Basic/OpenMPKinds.def"
453 case OMPD_target_enter_data:
455 #define OPENMP_TARGET_ENTER_DATA_CLAUSE(Name) \
458 #include "clang/Basic/OpenMPKinds.def"
463 case OMPD_target_exit_data:
465 #define OPENMP_TARGET_EXIT_DATA_CLAUSE(Name) \
468 #include "clang/Basic/OpenMPKinds.def"
473 case OMPD_target_parallel:
475 #define OPENMP_TARGET_PARALLEL_CLAUSE(Name) \
478 #include "clang/Basic/OpenMPKinds.def"
483 case OMPD_target_parallel_for:
485 #define OPENMP_TARGET_PARALLEL_FOR_CLAUSE(Name) \
488 #include "clang/Basic/OpenMPKinds.def"
493 case OMPD_target_update:
495 #define OPENMP_TARGET_UPDATE_CLAUSE(Name) \
498 #include "clang/Basic/OpenMPKinds.def"
505 #define OPENMP_TEAMS_CLAUSE(Name) \
508 #include "clang/Basic/OpenMPKinds.def"
513 case OMPD_declare_simd:
517 #define OPENMP_CANCEL_CLAUSE(Name) \
520 #include "clang/Basic/OpenMPKinds.def"
527 #define OPENMP_ORDERED_CLAUSE(Name) \
530 #include "clang/Basic/OpenMPKinds.def"
537 #define OPENMP_TASKLOOP_CLAUSE(Name) \
540 #include "clang/Basic/OpenMPKinds.def"
545 case OMPD_taskloop_simd:
547 #define OPENMP_TASKLOOP_SIMD_CLAUSE(Name) \
550 #include "clang/Basic/OpenMPKinds.def"
557 #define OPENMP_CRITICAL_CLAUSE(Name) \
560 #include "clang/Basic/OpenMPKinds.def"
565 case OMPD_distribute:
567 #define OPENMP_DISTRIBUTE_CLAUSE(Name) \
570 #include "clang/Basic/OpenMPKinds.def"
575 case OMPD_distribute_parallel_for:
577 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \
580 #include "clang/Basic/OpenMPKinds.def"
585 case OMPD_distribute_parallel_for_simd:
587 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \
590 #include "clang/Basic/OpenMPKinds.def"
595 case OMPD_distribute_simd:
597 #define OPENMP_DISTRIBUTE_SIMD_CLAUSE(Name) \
600 #include "clang/Basic/OpenMPKinds.def"
605 case OMPD_target_parallel_for_simd:
607 #define OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(Name) \
610 #include "clang/Basic/OpenMPKinds.def"
615 case OMPD_target_simd:
617 #define OPENMP_TARGET_SIMD_CLAUSE(Name) \
620 #include "clang/Basic/OpenMPKinds.def"
625 case OMPD_teams_distribute:
627 #define OPENMP_TEAMS_DISTRIBUTE_CLAUSE(Name) \
630 #include "clang/Basic/OpenMPKinds.def"
635 case OMPD_teams_distribute_simd:
637 #define OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \
640 #include "clang/Basic/OpenMPKinds.def"
645 case OMPD_teams_distribute_parallel_for_simd:
647 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \
650 #include "clang/Basic/OpenMPKinds.def"
655 case OMPD_teams_distribute_parallel_for:
657 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \
660 #include "clang/Basic/OpenMPKinds.def"
665 case OMPD_target_teams:
667 #define OPENMP_TARGET_TEAMS_CLAUSE(Name) \
670 #include "clang/Basic/OpenMPKinds.def"
675 case OMPD_target_teams_distribute:
677 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(Name) \
680 #include "clang/Basic/OpenMPKinds.def"
685 case OMPD_target_teams_distribute_parallel_for:
687 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \
690 #include "clang/Basic/OpenMPKinds.def"
695 case OMPD_target_teams_distribute_parallel_for_simd:
697 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \
700 #include "clang/Basic/OpenMPKinds.def"
705 case OMPD_target_teams_distribute_simd:
707 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \
710 #include "clang/Basic/OpenMPKinds.def"
717 #define OPENMP_TASKGROUP_CLAUSE(Name) \
720 #include "clang/Basic/OpenMPKinds.def"
725 case OMPD_declare_target:
726 case OMPD_end_declare_target:
728 case OMPD_threadprivate:
734 case OMPD_cancellation_point:
735 case OMPD_declare_reduction:
741 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
742 return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
743 DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
744 DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
745 DKind == OMPD_distribute || DKind == OMPD_target_parallel_for ||
746 DKind == OMPD_distribute_parallel_for ||
747 DKind == OMPD_distribute_parallel_for_simd ||
748 DKind == OMPD_distribute_simd ||
749 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
750 DKind == OMPD_teams_distribute ||
751 DKind == OMPD_teams_distribute_simd ||
752 DKind == OMPD_teams_distribute_parallel_for_simd ||
753 DKind == OMPD_teams_distribute_parallel_for ||
754 DKind == OMPD_target_teams_distribute ||
755 DKind == OMPD_target_teams_distribute_parallel_for ||
756 DKind == OMPD_target_teams_distribute_parallel_for_simd ||
757 DKind == OMPD_target_teams_distribute_simd;
760 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
761 return DKind == OMPD_for || DKind == OMPD_for_simd ||
762 DKind == OMPD_sections || DKind == OMPD_section ||
763 DKind == OMPD_single || DKind == OMPD_parallel_for ||
764 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
765 DKind == OMPD_target_parallel_for ||
766 DKind == OMPD_distribute_parallel_for ||
767 DKind == OMPD_distribute_parallel_for_simd ||
768 DKind == OMPD_target_parallel_for_simd ||
769 DKind == OMPD_teams_distribute_parallel_for_simd ||
770 DKind == OMPD_teams_distribute_parallel_for ||
771 DKind == OMPD_target_teams_distribute_parallel_for ||
772 DKind == OMPD_target_teams_distribute_parallel_for_simd;
775 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) {
776 return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd;
779 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
780 return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
781 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
782 DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for ||
783 DKind == OMPD_distribute_parallel_for ||
784 DKind == OMPD_distribute_parallel_for_simd ||
785 DKind == OMPD_target_parallel_for_simd ||
786 DKind == OMPD_teams_distribute_parallel_for ||
787 DKind == OMPD_teams_distribute_parallel_for_simd ||
788 DKind == OMPD_target_teams_distribute_parallel_for ||
789 DKind == OMPD_target_teams_distribute_parallel_for_simd;
792 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) {
793 return DKind == OMPD_target || DKind == OMPD_target_parallel ||
794 DKind == OMPD_target_parallel_for ||
795 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
796 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
797 DKind == OMPD_target_teams_distribute_parallel_for ||
798 DKind == OMPD_target_teams_distribute_parallel_for_simd ||
799 DKind == OMPD_target_teams_distribute_simd;
802 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) {
803 return DKind == OMPD_target_data || DKind == OMPD_target_enter_data ||
804 DKind == OMPD_target_exit_data || DKind == OMPD_target_update;
807 bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) {
808 return DKind == OMPD_teams || DKind == OMPD_teams_distribute ||
809 DKind == OMPD_teams_distribute_simd ||
810 DKind == OMPD_teams_distribute_parallel_for_simd ||
811 DKind == OMPD_teams_distribute_parallel_for;
814 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) {
815 return isOpenMPNestingTeamsDirective(DKind) ||
816 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
817 DKind == OMPD_target_teams_distribute_parallel_for ||
818 DKind == OMPD_target_teams_distribute_parallel_for_simd ||
819 DKind == OMPD_target_teams_distribute_simd;
822 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
823 return DKind == OMPD_simd || DKind == OMPD_for_simd ||
824 DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd ||
825 DKind == OMPD_distribute_parallel_for_simd ||
826 DKind == OMPD_distribute_simd || DKind == OMPD_target_simd ||
827 DKind == OMPD_teams_distribute_simd ||
828 DKind == OMPD_teams_distribute_parallel_for_simd ||
829 DKind == OMPD_target_teams_distribute_parallel_for_simd ||
830 DKind == OMPD_target_teams_distribute_simd;
833 bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) {
834 return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for ||
835 Kind == OMPD_distribute_parallel_for_simd ||
836 Kind == OMPD_distribute_simd;
837 // TODO add next directives.
840 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) {
841 return isOpenMPNestingDistributeDirective(Kind) ||
842 Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd ||
843 Kind == OMPD_teams_distribute_parallel_for_simd ||
844 Kind == OMPD_teams_distribute_parallel_for ||
845 Kind == OMPD_target_teams_distribute ||
846 Kind == OMPD_target_teams_distribute_parallel_for ||
847 Kind == OMPD_target_teams_distribute_parallel_for_simd ||
848 Kind == OMPD_target_teams_distribute_simd;
851 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
852 return Kind == OMPC_private || Kind == OMPC_firstprivate ||
853 Kind == OMPC_lastprivate || Kind == OMPC_linear ||
854 Kind == OMPC_reduction ||
855 Kind == OMPC_task_reduction; // TODO add next clauses like 'reduction'.
858 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
859 return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
862 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) {
863 return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind);
866 bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) {
867 return Kind == OMPD_distribute_parallel_for ||
868 Kind == OMPD_distribute_parallel_for_simd ||
869 Kind == OMPD_teams_distribute_parallel_for_simd ||
870 Kind == OMPD_teams_distribute_parallel_for ||
871 Kind == OMPD_target_teams_distribute_parallel_for ||
872 Kind == OMPD_target_teams_distribute_parallel_for_simd;
875 void clang::getOpenMPCaptureRegions(
876 SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions,
877 OpenMPDirectiveKind DKind) {
878 assert(DKind <= OMPD_unknown);
881 case OMPD_parallel_for:
882 case OMPD_parallel_for_simd:
883 case OMPD_parallel_sections:
884 case OMPD_distribute_parallel_for:
885 CaptureRegions.push_back(OMPD_parallel);
887 case OMPD_target_teams:
888 CaptureRegions.push_back(OMPD_target);
889 CaptureRegions.push_back(OMPD_teams);
901 case OMPD_distribute:
904 case OMPD_target_data:
906 case OMPD_target_parallel_for:
907 case OMPD_target_parallel_for_simd:
908 case OMPD_target_simd:
911 case OMPD_taskloop_simd:
912 case OMPD_distribute_parallel_for_simd:
913 case OMPD_distribute_simd:
914 case OMPD_teams_distribute:
915 case OMPD_teams_distribute_simd:
916 case OMPD_teams_distribute_parallel_for_simd:
917 case OMPD_teams_distribute_parallel_for:
918 case OMPD_target_teams_distribute:
919 case OMPD_target_teams_distribute_parallel_for:
920 case OMPD_target_teams_distribute_parallel_for_simd:
921 case OMPD_target_teams_distribute_simd:
922 CaptureRegions.push_back(DKind);
924 case OMPD_target_parallel:
925 CaptureRegions.push_back(OMPD_target);
926 CaptureRegions.push_back(OMPD_parallel);
928 case OMPD_threadprivate:
932 case OMPD_cancellation_point:
935 case OMPD_target_enter_data:
936 case OMPD_target_exit_data:
937 case OMPD_declare_reduction:
938 case OMPD_declare_simd:
939 case OMPD_declare_target:
940 case OMPD_end_declare_target:
941 case OMPD_target_update:
942 llvm_unreachable("OpenMP Directive is not allowed");
944 llvm_unreachable("Unknown OpenMP directive");