1 //===--- OpenMPKinds.cpp - Token Kinds Support ----------------------------===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 /// This file implements the OpenMP enum and support functions.
11 //===----------------------------------------------------------------------===//
13 #include "clang/Basic/OpenMPKinds.h"
14 #include "clang/Basic/IdentifierTable.h"
15 #include "llvm/ADT/StringRef.h"
16 #include "llvm/ADT/StringSwitch.h"
17 #include "llvm/Support/ErrorHandling.h"
20 using namespace clang;
21 using namespace llvm::omp;
23 OpenMPContextSelectorSetKind
24 clang::getOpenMPContextSelectorSet(llvm::StringRef Str) {
25 return llvm::StringSwitch<OpenMPContextSelectorSetKind>(Str)
26 #define OPENMP_CONTEXT_SELECTOR_SET(Name) .Case(#Name, OMP_CTX_SET_##Name)
27 #include "clang/Basic/OpenMPKinds.def"
28 .Default(OMP_CTX_SET_unknown);
32 clang::getOpenMPContextSelectorSetName(OpenMPContextSelectorSetKind Kind) {
34 case OMP_CTX_SET_unknown:
36 #define OPENMP_CONTEXT_SELECTOR_SET(Name) \
37 case OMP_CTX_SET_##Name: \
39 #include "clang/Basic/OpenMPKinds.def"
42 llvm_unreachable("Invalid OpenMP context selector set kind");
45 OpenMPContextSelectorKind clang::getOpenMPContextSelector(llvm::StringRef Str) {
46 return llvm::StringSwitch<OpenMPContextSelectorKind>(Str)
47 #define OPENMP_CONTEXT_SELECTOR(Name) .Case(#Name, OMP_CTX_##Name)
48 #include "clang/Basic/OpenMPKinds.def"
49 .Default(OMP_CTX_unknown);
53 clang::getOpenMPContextSelectorName(OpenMPContextSelectorKind Kind) {
57 #define OPENMP_CONTEXT_SELECTOR(Name) \
58 case OMP_CTX_##Name: \
60 #include "clang/Basic/OpenMPKinds.def"
63 llvm_unreachable("Invalid OpenMP context selector kind");
66 OpenMPClauseKind clang::getOpenMPClauseKind(StringRef Str) {
67 // 'flush' clause cannot be specified explicitly, because this is an implicit
68 // clause for 'flush' directive. If the 'flush' clause is explicitly specified
69 // the Parser should generate a warning about extra tokens at the end of the
73 return llvm::StringSwitch<OpenMPClauseKind>(Str)
74 #define OPENMP_CLAUSE(Name, Class) .Case(#Name, OMPC_##Name)
75 #include "clang/Basic/OpenMPKinds.def"
76 .Case("uniform", OMPC_uniform)
77 .Case("device_type", OMPC_device_type)
78 .Case("match", OMPC_match)
79 .Default(OMPC_unknown);
82 const char *clang::getOpenMPClauseName(OpenMPClauseKind Kind) {
83 assert(Kind <= OMPC_unknown);
87 #define OPENMP_CLAUSE(Name, Class) \
90 #include "clang/Basic/OpenMPKinds.def"
93 case OMPC_threadprivate:
94 return "threadprivate or thread local";
95 case OMPC_device_type:
100 llvm_unreachable("Invalid OpenMP clause kind");
103 unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind,
107 return llvm::StringSwitch<OpenMPDefaultClauseKind>(Str)
108 #define OPENMP_DEFAULT_KIND(Name) .Case(#Name, OMPC_DEFAULT_##Name)
109 #include "clang/Basic/OpenMPKinds.def"
110 .Default(OMPC_DEFAULT_unknown);
112 return llvm::StringSwitch<unsigned>(Str)
113 #define OMP_PROC_BIND_KIND(Enum, Name, Value) .Case(Name, Value)
114 #include "llvm/Frontend/OpenMP/OMPKinds.def"
115 .Default(unsigned(llvm::omp::OMP_PROC_BIND_unknown));
117 return llvm::StringSwitch<unsigned>(Str)
118 #define OPENMP_SCHEDULE_KIND(Name) \
119 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_##Name))
120 #define OPENMP_SCHEDULE_MODIFIER(Name) \
121 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_MODIFIER_##Name))
122 #include "clang/Basic/OpenMPKinds.def"
123 .Default(OMPC_SCHEDULE_unknown);
125 return llvm::StringSwitch<OpenMPDependClauseKind>(Str)
126 #define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name)
127 #include "clang/Basic/OpenMPKinds.def"
128 .Default(OMPC_DEPEND_unknown);
130 return llvm::StringSwitch<OpenMPLinearClauseKind>(Str)
131 #define OPENMP_LINEAR_KIND(Name) .Case(#Name, OMPC_LINEAR_##Name)
132 #include "clang/Basic/OpenMPKinds.def"
133 .Default(OMPC_LINEAR_unknown);
135 return llvm::StringSwitch<unsigned>(Str)
136 #define OPENMP_MAP_KIND(Name) \
137 .Case(#Name, static_cast<unsigned>(OMPC_MAP_##Name))
138 #define OPENMP_MAP_MODIFIER_KIND(Name) \
139 .Case(#Name, static_cast<unsigned>(OMPC_MAP_MODIFIER_##Name))
140 #include "clang/Basic/OpenMPKinds.def"
141 .Default(OMPC_MAP_unknown);
143 return llvm::StringSwitch<unsigned>(Str)
144 #define OPENMP_TO_MODIFIER_KIND(Name) \
145 .Case(#Name, static_cast<unsigned>(OMPC_TO_MODIFIER_##Name))
146 #include "clang/Basic/OpenMPKinds.def"
147 .Default(OMPC_TO_MODIFIER_unknown);
149 return llvm::StringSwitch<unsigned>(Str)
150 #define OPENMP_FROM_MODIFIER_KIND(Name) \
151 .Case(#Name, static_cast<unsigned>(OMPC_FROM_MODIFIER_##Name))
152 #include "clang/Basic/OpenMPKinds.def"
153 .Default(OMPC_FROM_MODIFIER_unknown);
154 case OMPC_dist_schedule:
155 return llvm::StringSwitch<OpenMPDistScheduleClauseKind>(Str)
156 #define OPENMP_DIST_SCHEDULE_KIND(Name) .Case(#Name, OMPC_DIST_SCHEDULE_##Name)
157 #include "clang/Basic/OpenMPKinds.def"
158 .Default(OMPC_DIST_SCHEDULE_unknown);
159 case OMPC_defaultmap:
160 return llvm::StringSwitch<unsigned>(Str)
161 #define OPENMP_DEFAULTMAP_KIND(Name) \
162 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_##Name))
163 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \
164 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_MODIFIER_##Name))
165 #include "clang/Basic/OpenMPKinds.def"
166 .Default(OMPC_DEFAULTMAP_unknown);
167 case OMPC_atomic_default_mem_order:
168 return llvm::StringSwitch<OpenMPAtomicDefaultMemOrderClauseKind>(Str)
169 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \
170 .Case(#Name, OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name)
171 #include "clang/Basic/OpenMPKinds.def"
172 .Default(OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown);
173 case OMPC_device_type:
174 return llvm::StringSwitch<OpenMPDeviceType>(Str)
175 #define OPENMP_DEVICE_TYPE_KIND(Name) .Case(#Name, OMPC_DEVICE_TYPE_##Name)
176 #include "clang/Basic/OpenMPKinds.def"
177 .Default(OMPC_DEVICE_TYPE_unknown);
178 case OMPC_lastprivate:
179 return llvm::StringSwitch<OpenMPLastprivateModifier>(Str)
180 #define OPENMP_LASTPRIVATE_KIND(Name) .Case(#Name, OMPC_LASTPRIVATE_##Name)
181 #include "clang/Basic/OpenMPKinds.def"
182 .Default(OMPC_LASTPRIVATE_unknown);
184 case OMPC_threadprivate:
187 case OMPC_num_threads:
194 case OMPC_firstprivate:
197 case OMPC_task_reduction:
198 case OMPC_in_reduction:
201 case OMPC_copyprivate:
216 case OMPC_thread_limit:
223 case OMPC_use_device_ptr:
224 case OMPC_is_device_ptr:
225 case OMPC_unified_address:
226 case OMPC_unified_shared_memory:
227 case OMPC_reverse_offload:
228 case OMPC_dynamic_allocators:
230 case OMPC_nontemporal:
233 llvm_unreachable("Invalid OpenMP simple clause kind");
236 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
241 case OMPC_DEFAULT_unknown:
243 #define OPENMP_DEFAULT_KIND(Name) \
244 case OMPC_DEFAULT_##Name: \
246 #include "clang/Basic/OpenMPKinds.def"
248 llvm_unreachable("Invalid OpenMP 'default' clause type");
251 #define OMP_PROC_BIND_KIND(Enum, Name, Value) \
254 #include "llvm/Frontend/OpenMP/OMPKinds.def"
256 llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
259 case OMPC_SCHEDULE_unknown:
260 case OMPC_SCHEDULE_MODIFIER_last:
262 #define OPENMP_SCHEDULE_KIND(Name) \
263 case OMPC_SCHEDULE_##Name: \
265 #define OPENMP_SCHEDULE_MODIFIER(Name) \
266 case OMPC_SCHEDULE_MODIFIER_##Name: \
268 #include "clang/Basic/OpenMPKinds.def"
270 llvm_unreachable("Invalid OpenMP 'schedule' clause type");
273 case OMPC_DEPEND_unknown:
275 #define OPENMP_DEPEND_KIND(Name) \
276 case OMPC_DEPEND_##Name: \
278 #include "clang/Basic/OpenMPKinds.def"
280 llvm_unreachable("Invalid OpenMP 'depend' clause type");
283 case OMPC_LINEAR_unknown:
285 #define OPENMP_LINEAR_KIND(Name) \
286 case OMPC_LINEAR_##Name: \
288 #include "clang/Basic/OpenMPKinds.def"
290 llvm_unreachable("Invalid OpenMP 'linear' clause type");
293 case OMPC_MAP_unknown:
294 case OMPC_MAP_MODIFIER_last:
296 #define OPENMP_MAP_KIND(Name) \
297 case OMPC_MAP_##Name: \
299 #define OPENMP_MAP_MODIFIER_KIND(Name) \
300 case OMPC_MAP_MODIFIER_##Name: \
302 #include "clang/Basic/OpenMPKinds.def"
306 llvm_unreachable("Invalid OpenMP 'map' clause type");
309 case OMPC_TO_MODIFIER_unknown:
311 #define OPENMP_TO_MODIFIER_KIND(Name) \
312 case OMPC_TO_MODIFIER_##Name: \
314 #include "clang/Basic/OpenMPKinds.def"
318 llvm_unreachable("Invalid OpenMP 'to' clause type");
321 case OMPC_FROM_MODIFIER_unknown:
323 #define OPENMP_FROM_MODIFIER_KIND(Name) \
324 case OMPC_FROM_MODIFIER_##Name: \
326 #include "clang/Basic/OpenMPKinds.def"
330 llvm_unreachable("Invalid OpenMP 'from' clause type");
331 case OMPC_dist_schedule:
333 case OMPC_DIST_SCHEDULE_unknown:
335 #define OPENMP_DIST_SCHEDULE_KIND(Name) \
336 case OMPC_DIST_SCHEDULE_##Name: \
338 #include "clang/Basic/OpenMPKinds.def"
340 llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type");
341 case OMPC_defaultmap:
343 case OMPC_DEFAULTMAP_unknown:
344 case OMPC_DEFAULTMAP_MODIFIER_last:
346 #define OPENMP_DEFAULTMAP_KIND(Name) \
347 case OMPC_DEFAULTMAP_##Name: \
349 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \
350 case OMPC_DEFAULTMAP_MODIFIER_##Name: \
352 #include "clang/Basic/OpenMPKinds.def"
354 llvm_unreachable("Invalid OpenMP 'schedule' clause type");
355 case OMPC_atomic_default_mem_order:
357 case OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown:
359 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \
360 case OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name: \
362 #include "clang/Basic/OpenMPKinds.def"
364 llvm_unreachable("Invalid OpenMP 'atomic_default_mem_order' clause type");
365 case OMPC_device_type:
367 case OMPC_DEVICE_TYPE_unknown:
369 #define OPENMP_DEVICE_TYPE_KIND(Name) \
370 case OMPC_DEVICE_TYPE_##Name: \
372 #include "clang/Basic/OpenMPKinds.def"
374 llvm_unreachable("Invalid OpenMP 'device_type' clause type");
375 case OMPC_lastprivate:
377 case OMPC_LASTPRIVATE_unknown:
379 #define OPENMP_LASTPRIVATE_KIND(Name) \
380 case OMPC_LASTPRIVATE_##Name: \
382 #include "clang/Basic/OpenMPKinds.def"
384 llvm_unreachable("Invalid OpenMP 'lastprivate' clause type");
386 case OMPC_threadprivate:
389 case OMPC_num_threads:
396 case OMPC_firstprivate:
399 case OMPC_task_reduction:
400 case OMPC_in_reduction:
403 case OMPC_copyprivate:
418 case OMPC_thread_limit:
425 case OMPC_use_device_ptr:
426 case OMPC_is_device_ptr:
427 case OMPC_unified_address:
428 case OMPC_unified_shared_memory:
429 case OMPC_reverse_offload:
430 case OMPC_dynamic_allocators:
432 case OMPC_nontemporal:
435 llvm_unreachable("Invalid OpenMP simple clause kind");
438 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
439 OpenMPClauseKind CKind,
440 unsigned OpenMPVersion) {
441 assert(unsigned(DKind) <= unsigned(OMPD_unknown));
442 assert(CKind <= OMPC_unknown);
443 // Nontemporal clause is not supported in OpenMP < 5.0.
444 if (OpenMPVersion < 50 && CKind == OMPC_nontemporal)
449 #define OPENMP_PARALLEL_CLAUSE(Name) \
452 #include "clang/Basic/OpenMPKinds.def"
458 if (OpenMPVersion < 50 && CKind == OMPC_if)
461 #define OPENMP_SIMD_CLAUSE(Name) \
464 #include "clang/Basic/OpenMPKinds.def"
471 #define OPENMP_FOR_CLAUSE(Name) \
474 #include "clang/Basic/OpenMPKinds.def"
480 if (OpenMPVersion < 50 && CKind == OMPC_if)
483 #define OPENMP_FOR_SIMD_CLAUSE(Name) \
486 #include "clang/Basic/OpenMPKinds.def"
493 #define OPENMP_SECTIONS_CLAUSE(Name) \
496 #include "clang/Basic/OpenMPKinds.def"
503 #define OPENMP_SINGLE_CLAUSE(Name) \
506 #include "clang/Basic/OpenMPKinds.def"
511 case OMPD_parallel_for:
513 #define OPENMP_PARALLEL_FOR_CLAUSE(Name) \
516 #include "clang/Basic/OpenMPKinds.def"
521 case OMPD_parallel_for_simd:
523 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name) \
526 #include "clang/Basic/OpenMPKinds.def"
531 case OMPD_parallel_master:
533 #define OPENMP_PARALLEL_MASTER_CLAUSE(Name) \
536 #include "clang/Basic/OpenMPKinds.def"
541 case OMPD_parallel_sections:
543 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name) \
546 #include "clang/Basic/OpenMPKinds.def"
553 #define OPENMP_TASK_CLAUSE(Name) \
556 #include "clang/Basic/OpenMPKinds.def"
562 return CKind == OMPC_flush;
566 #define OPENMP_ATOMIC_CLAUSE(Name) \
569 #include "clang/Basic/OpenMPKinds.def"
576 #define OPENMP_TARGET_CLAUSE(Name) \
579 #include "clang/Basic/OpenMPKinds.def"
586 #define OPENMP_REQUIRES_CLAUSE(Name) \
589 #include "clang/Basic/OpenMPKinds.def"
594 case OMPD_target_data:
596 #define OPENMP_TARGET_DATA_CLAUSE(Name) \
599 #include "clang/Basic/OpenMPKinds.def"
604 case OMPD_target_enter_data:
606 #define OPENMP_TARGET_ENTER_DATA_CLAUSE(Name) \
609 #include "clang/Basic/OpenMPKinds.def"
614 case OMPD_target_exit_data:
616 #define OPENMP_TARGET_EXIT_DATA_CLAUSE(Name) \
619 #include "clang/Basic/OpenMPKinds.def"
624 case OMPD_target_parallel:
626 #define OPENMP_TARGET_PARALLEL_CLAUSE(Name) \
629 #include "clang/Basic/OpenMPKinds.def"
634 case OMPD_target_parallel_for:
636 #define OPENMP_TARGET_PARALLEL_FOR_CLAUSE(Name) \
639 #include "clang/Basic/OpenMPKinds.def"
644 case OMPD_target_update:
646 #define OPENMP_TARGET_UPDATE_CLAUSE(Name) \
649 #include "clang/Basic/OpenMPKinds.def"
656 #define OPENMP_TEAMS_CLAUSE(Name) \
659 #include "clang/Basic/OpenMPKinds.def"
666 #define OPENMP_CANCEL_CLAUSE(Name) \
669 #include "clang/Basic/OpenMPKinds.def"
676 #define OPENMP_ORDERED_CLAUSE(Name) \
679 #include "clang/Basic/OpenMPKinds.def"
686 #define OPENMP_TASKLOOP_CLAUSE(Name) \
689 #include "clang/Basic/OpenMPKinds.def"
694 case OMPD_taskloop_simd:
696 #define OPENMP_TASKLOOP_SIMD_CLAUSE(Name) \
699 #include "clang/Basic/OpenMPKinds.def"
704 case OMPD_master_taskloop:
706 #define OPENMP_MASTER_TASKLOOP_CLAUSE(Name) \
709 #include "clang/Basic/OpenMPKinds.def"
714 case OMPD_master_taskloop_simd:
716 #define OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(Name) \
719 #include "clang/Basic/OpenMPKinds.def"
724 case OMPD_parallel_master_taskloop:
726 #define OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(Name) \
729 #include "clang/Basic/OpenMPKinds.def"
734 case OMPD_parallel_master_taskloop_simd:
736 #define OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(Name) \
739 #include "clang/Basic/OpenMPKinds.def"
746 #define OPENMP_CRITICAL_CLAUSE(Name) \
749 #include "clang/Basic/OpenMPKinds.def"
754 case OMPD_distribute:
756 #define OPENMP_DISTRIBUTE_CLAUSE(Name) \
759 #include "clang/Basic/OpenMPKinds.def"
764 case OMPD_distribute_parallel_for:
766 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \
769 #include "clang/Basic/OpenMPKinds.def"
774 case OMPD_distribute_parallel_for_simd:
776 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \
779 #include "clang/Basic/OpenMPKinds.def"
784 case OMPD_distribute_simd:
785 if (OpenMPVersion < 50 && CKind == OMPC_if)
788 #define OPENMP_DISTRIBUTE_SIMD_CLAUSE(Name) \
791 #include "clang/Basic/OpenMPKinds.def"
796 case OMPD_target_parallel_for_simd:
798 #define OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(Name) \
801 #include "clang/Basic/OpenMPKinds.def"
806 case OMPD_target_simd:
808 #define OPENMP_TARGET_SIMD_CLAUSE(Name) \
811 #include "clang/Basic/OpenMPKinds.def"
816 case OMPD_teams_distribute:
818 #define OPENMP_TEAMS_DISTRIBUTE_CLAUSE(Name) \
821 #include "clang/Basic/OpenMPKinds.def"
826 case OMPD_teams_distribute_simd:
827 if (OpenMPVersion < 50 && CKind == OMPC_if)
830 #define OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \
833 #include "clang/Basic/OpenMPKinds.def"
838 case OMPD_teams_distribute_parallel_for_simd:
840 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \
843 #include "clang/Basic/OpenMPKinds.def"
848 case OMPD_teams_distribute_parallel_for:
850 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \
853 #include "clang/Basic/OpenMPKinds.def"
858 case OMPD_target_teams:
860 #define OPENMP_TARGET_TEAMS_CLAUSE(Name) \
863 #include "clang/Basic/OpenMPKinds.def"
868 case OMPD_target_teams_distribute:
870 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(Name) \
873 #include "clang/Basic/OpenMPKinds.def"
878 case OMPD_target_teams_distribute_parallel_for:
880 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \
883 #include "clang/Basic/OpenMPKinds.def"
888 case OMPD_target_teams_distribute_parallel_for_simd:
890 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \
893 #include "clang/Basic/OpenMPKinds.def"
898 case OMPD_target_teams_distribute_simd:
900 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \
903 #include "clang/Basic/OpenMPKinds.def"
910 #define OPENMP_TASKGROUP_CLAUSE(Name) \
913 #include "clang/Basic/OpenMPKinds.def"
918 case OMPD_declare_mapper:
920 #define OPENMP_DECLARE_MAPPER_CLAUSE(Name) \
923 #include "clang/Basic/OpenMPKinds.def"
930 #define OPENMP_ALLOCATE_CLAUSE(Name) \
933 #include "clang/Basic/OpenMPKinds.def"
938 case OMPD_declare_variant:
940 #define OPENMP_DECLARE_VARIANT_CLAUSE(Name) \
943 #include "clang/Basic/OpenMPKinds.def"
948 case OMPD_declare_target:
949 case OMPD_end_declare_target:
951 case OMPD_threadprivate:
957 case OMPD_cancellation_point:
958 case OMPD_declare_reduction:
959 case OMPD_declare_simd:
965 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
966 return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
967 DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
968 DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
969 DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd ||
970 DKind == OMPD_parallel_master_taskloop ||
971 DKind == OMPD_parallel_master_taskloop_simd ||
972 DKind == OMPD_distribute || DKind == OMPD_target_parallel_for ||
973 DKind == OMPD_distribute_parallel_for ||
974 DKind == OMPD_distribute_parallel_for_simd ||
975 DKind == OMPD_distribute_simd ||
976 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
977 DKind == OMPD_teams_distribute ||
978 DKind == OMPD_teams_distribute_simd ||
979 DKind == OMPD_teams_distribute_parallel_for_simd ||
980 DKind == OMPD_teams_distribute_parallel_for ||
981 DKind == OMPD_target_teams_distribute ||
982 DKind == OMPD_target_teams_distribute_parallel_for ||
983 DKind == OMPD_target_teams_distribute_parallel_for_simd ||
984 DKind == OMPD_target_teams_distribute_simd;
987 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
988 return DKind == OMPD_for || DKind == OMPD_for_simd ||
989 DKind == OMPD_sections || DKind == OMPD_section ||
990 DKind == OMPD_single || DKind == OMPD_parallel_for ||
991 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
992 DKind == OMPD_target_parallel_for ||
993 DKind == OMPD_distribute_parallel_for ||
994 DKind == OMPD_distribute_parallel_for_simd ||
995 DKind == OMPD_target_parallel_for_simd ||
996 DKind == OMPD_teams_distribute_parallel_for_simd ||
997 DKind == OMPD_teams_distribute_parallel_for ||
998 DKind == OMPD_target_teams_distribute_parallel_for ||
999 DKind == OMPD_target_teams_distribute_parallel_for_simd;
1002 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) {
1003 return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
1004 DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd ||
1005 DKind == OMPD_parallel_master_taskloop ||
1006 DKind == OMPD_parallel_master_taskloop_simd;
1009 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
1010 return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
1011 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
1012 DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for ||
1013 DKind == OMPD_distribute_parallel_for ||
1014 DKind == OMPD_distribute_parallel_for_simd ||
1015 DKind == OMPD_target_parallel_for_simd ||
1016 DKind == OMPD_teams_distribute_parallel_for ||
1017 DKind == OMPD_teams_distribute_parallel_for_simd ||
1018 DKind == OMPD_target_teams_distribute_parallel_for ||
1019 DKind == OMPD_target_teams_distribute_parallel_for_simd ||
1020 DKind == OMPD_parallel_master ||
1021 DKind == OMPD_parallel_master_taskloop ||
1022 DKind == OMPD_parallel_master_taskloop_simd;
1025 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) {
1026 return DKind == OMPD_target || DKind == OMPD_target_parallel ||
1027 DKind == OMPD_target_parallel_for ||
1028 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
1029 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
1030 DKind == OMPD_target_teams_distribute_parallel_for ||
1031 DKind == OMPD_target_teams_distribute_parallel_for_simd ||
1032 DKind == OMPD_target_teams_distribute_simd;
1035 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) {
1036 return DKind == OMPD_target_data || DKind == OMPD_target_enter_data ||
1037 DKind == OMPD_target_exit_data || DKind == OMPD_target_update;
1040 bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) {
1041 return DKind == OMPD_teams || DKind == OMPD_teams_distribute ||
1042 DKind == OMPD_teams_distribute_simd ||
1043 DKind == OMPD_teams_distribute_parallel_for_simd ||
1044 DKind == OMPD_teams_distribute_parallel_for;
1047 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) {
1048 return isOpenMPNestingTeamsDirective(DKind) ||
1049 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
1050 DKind == OMPD_target_teams_distribute_parallel_for ||
1051 DKind == OMPD_target_teams_distribute_parallel_for_simd ||
1052 DKind == OMPD_target_teams_distribute_simd;
1055 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
1056 return DKind == OMPD_simd || DKind == OMPD_for_simd ||
1057 DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd ||
1058 DKind == OMPD_master_taskloop_simd ||
1059 DKind == OMPD_parallel_master_taskloop_simd ||
1060 DKind == OMPD_distribute_parallel_for_simd ||
1061 DKind == OMPD_distribute_simd || DKind == OMPD_target_simd ||
1062 DKind == OMPD_teams_distribute_simd ||
1063 DKind == OMPD_teams_distribute_parallel_for_simd ||
1064 DKind == OMPD_target_teams_distribute_parallel_for_simd ||
1065 DKind == OMPD_target_teams_distribute_simd ||
1066 DKind == OMPD_target_parallel_for_simd;
1069 bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) {
1070 return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for ||
1071 Kind == OMPD_distribute_parallel_for_simd ||
1072 Kind == OMPD_distribute_simd;
1073 // TODO add next directives.
1076 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) {
1077 return isOpenMPNestingDistributeDirective(Kind) ||
1078 Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd ||
1079 Kind == OMPD_teams_distribute_parallel_for_simd ||
1080 Kind == OMPD_teams_distribute_parallel_for ||
1081 Kind == OMPD_target_teams_distribute ||
1082 Kind == OMPD_target_teams_distribute_parallel_for ||
1083 Kind == OMPD_target_teams_distribute_parallel_for_simd ||
1084 Kind == OMPD_target_teams_distribute_simd;
1087 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
1088 return Kind == OMPC_private || Kind == OMPC_firstprivate ||
1089 Kind == OMPC_lastprivate || Kind == OMPC_linear ||
1090 Kind == OMPC_reduction || Kind == OMPC_task_reduction ||
1091 Kind == OMPC_in_reduction; // TODO add next clauses like 'reduction'.
1094 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
1095 return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
1098 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) {
1099 return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind);
1102 bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) {
1103 return Kind == OMPD_distribute_parallel_for ||
1104 Kind == OMPD_distribute_parallel_for_simd ||
1105 Kind == OMPD_teams_distribute_parallel_for_simd ||
1106 Kind == OMPD_teams_distribute_parallel_for ||
1107 Kind == OMPD_target_teams_distribute_parallel_for ||
1108 Kind == OMPD_target_teams_distribute_parallel_for_simd;
1111 void clang::getOpenMPCaptureRegions(
1112 SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions,
1113 OpenMPDirectiveKind DKind) {
1114 assert(DKind <= OMPD_unknown);
1117 case OMPD_parallel_for:
1118 case OMPD_parallel_for_simd:
1119 case OMPD_parallel_master:
1120 case OMPD_parallel_sections:
1121 case OMPD_distribute_parallel_for:
1122 case OMPD_distribute_parallel_for_simd:
1123 CaptureRegions.push_back(OMPD_parallel);
1125 case OMPD_target_teams:
1126 case OMPD_target_teams_distribute:
1127 case OMPD_target_teams_distribute_simd:
1128 CaptureRegions.push_back(OMPD_task);
1129 CaptureRegions.push_back(OMPD_target);
1130 CaptureRegions.push_back(OMPD_teams);
1133 case OMPD_teams_distribute:
1134 case OMPD_teams_distribute_simd:
1135 CaptureRegions.push_back(OMPD_teams);
1138 case OMPD_target_simd:
1139 CaptureRegions.push_back(OMPD_task);
1140 CaptureRegions.push_back(OMPD_target);
1142 case OMPD_teams_distribute_parallel_for:
1143 case OMPD_teams_distribute_parallel_for_simd:
1144 CaptureRegions.push_back(OMPD_teams);
1145 CaptureRegions.push_back(OMPD_parallel);
1147 case OMPD_target_parallel:
1148 case OMPD_target_parallel_for:
1149 case OMPD_target_parallel_for_simd:
1150 CaptureRegions.push_back(OMPD_task);
1151 CaptureRegions.push_back(OMPD_target);
1152 CaptureRegions.push_back(OMPD_parallel);
1155 case OMPD_target_enter_data:
1156 case OMPD_target_exit_data:
1157 case OMPD_target_update:
1158 CaptureRegions.push_back(OMPD_task);
1161 case OMPD_taskloop_simd:
1162 case OMPD_master_taskloop:
1163 case OMPD_master_taskloop_simd:
1164 CaptureRegions.push_back(OMPD_taskloop);
1166 case OMPD_parallel_master_taskloop:
1167 case OMPD_parallel_master_taskloop_simd:
1168 CaptureRegions.push_back(OMPD_parallel);
1169 CaptureRegions.push_back(OMPD_taskloop);
1171 case OMPD_target_teams_distribute_parallel_for:
1172 case OMPD_target_teams_distribute_parallel_for_simd:
1173 CaptureRegions.push_back(OMPD_task);
1174 CaptureRegions.push_back(OMPD_target);
1175 CaptureRegions.push_back(OMPD_teams);
1176 CaptureRegions.push_back(OMPD_parallel);
1186 case OMPD_taskgroup:
1187 case OMPD_distribute:
1190 case OMPD_target_data:
1191 case OMPD_distribute_simd:
1192 CaptureRegions.push_back(OMPD_unknown);
1194 case OMPD_threadprivate:
1196 case OMPD_taskyield:
1199 case OMPD_cancellation_point:
1202 case OMPD_declare_reduction:
1203 case OMPD_declare_mapper:
1204 case OMPD_declare_simd:
1205 case OMPD_declare_target:
1206 case OMPD_end_declare_target:
1208 case OMPD_declare_variant:
1209 llvm_unreachable("OpenMP Directive is not allowed");
1211 llvm_unreachable("Unknown OpenMP directive");