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 .Default(OMPC_unknown);
61 const char *clang::getOpenMPClauseName(OpenMPClauseKind Kind) {
62 assert(Kind <= OMPC_unknown);
66 #define OPENMP_CLAUSE(Name, Class) \
69 #include "clang/Basic/OpenMPKinds.def"
70 case OMPC_threadprivate:
71 return "threadprivate or thread local";
73 llvm_unreachable("Invalid OpenMP clause kind");
76 unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind,
80 return llvm::StringSwitch<OpenMPDefaultClauseKind>(Str)
81 #define OPENMP_DEFAULT_KIND(Name) .Case(#Name, OMPC_DEFAULT_##Name)
82 #include "clang/Basic/OpenMPKinds.def"
83 .Default(OMPC_DEFAULT_unknown);
85 return llvm::StringSwitch<OpenMPProcBindClauseKind>(Str)
86 #define OPENMP_PROC_BIND_KIND(Name) .Case(#Name, OMPC_PROC_BIND_##Name)
87 #include "clang/Basic/OpenMPKinds.def"
88 .Default(OMPC_PROC_BIND_unknown);
90 return llvm::StringSwitch<unsigned>(Str)
91 #define OPENMP_SCHEDULE_KIND(Name) \
92 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_##Name))
93 #define OPENMP_SCHEDULE_MODIFIER(Name) \
94 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_MODIFIER_##Name))
95 #include "clang/Basic/OpenMPKinds.def"
96 .Default(OMPC_SCHEDULE_unknown);
98 return llvm::StringSwitch<OpenMPDependClauseKind>(Str)
99 #define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name)
100 #include "clang/Basic/OpenMPKinds.def"
101 .Default(OMPC_DEPEND_unknown);
103 return llvm::StringSwitch<OpenMPLinearClauseKind>(Str)
104 #define OPENMP_LINEAR_KIND(Name) .Case(#Name, OMPC_LINEAR_##Name)
105 #include "clang/Basic/OpenMPKinds.def"
106 .Default(OMPC_LINEAR_unknown);
108 return llvm::StringSwitch<OpenMPMapClauseKind>(Str)
109 #define OPENMP_MAP_KIND(Name) .Case(#Name, OMPC_MAP_##Name)
110 #include "clang/Basic/OpenMPKinds.def"
111 .Default(OMPC_MAP_unknown);
113 case OMPC_threadprivate:
116 case OMPC_num_threads:
121 case OMPC_firstprivate:
122 case OMPC_lastprivate:
127 case OMPC_copyprivate:
142 case OMPC_thread_limit:
150 llvm_unreachable("Invalid OpenMP simple clause kind");
153 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
158 case OMPC_DEFAULT_unknown:
160 #define OPENMP_DEFAULT_KIND(Name) \
161 case OMPC_DEFAULT_##Name: \
163 #include "clang/Basic/OpenMPKinds.def"
165 llvm_unreachable("Invalid OpenMP 'default' clause type");
168 case OMPC_PROC_BIND_unknown:
170 #define OPENMP_PROC_BIND_KIND(Name) \
171 case OMPC_PROC_BIND_##Name: \
173 #include "clang/Basic/OpenMPKinds.def"
175 llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
178 case OMPC_SCHEDULE_unknown:
179 case OMPC_SCHEDULE_MODIFIER_last:
181 #define OPENMP_SCHEDULE_KIND(Name) \
182 case OMPC_SCHEDULE_##Name: \
184 #define OPENMP_SCHEDULE_MODIFIER(Name) \
185 case OMPC_SCHEDULE_MODIFIER_##Name: \
187 #include "clang/Basic/OpenMPKinds.def"
189 llvm_unreachable("Invalid OpenMP 'schedule' clause type");
192 case OMPC_DEPEND_unknown:
194 #define OPENMP_DEPEND_KIND(Name) \
195 case OMPC_DEPEND_##Name: \
197 #include "clang/Basic/OpenMPKinds.def"
199 llvm_unreachable("Invalid OpenMP 'depend' clause type");
202 case OMPC_LINEAR_unknown:
204 #define OPENMP_LINEAR_KIND(Name) \
205 case OMPC_LINEAR_##Name: \
207 #include "clang/Basic/OpenMPKinds.def"
209 llvm_unreachable("Invalid OpenMP 'linear' clause type");
212 case OMPC_MAP_unknown:
214 #define OPENMP_MAP_KIND(Name) \
215 case OMPC_MAP_##Name: \
217 #include "clang/Basic/OpenMPKinds.def"
221 llvm_unreachable("Invalid OpenMP 'map' clause type");
223 case OMPC_threadprivate:
226 case OMPC_num_threads:
231 case OMPC_firstprivate:
232 case OMPC_lastprivate:
237 case OMPC_copyprivate:
252 case OMPC_thread_limit:
260 llvm_unreachable("Invalid OpenMP simple clause kind");
263 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
264 OpenMPClauseKind CKind) {
265 assert(DKind <= OMPD_unknown);
266 assert(CKind <= OMPC_unknown);
270 #define OPENMP_PARALLEL_CLAUSE(Name) \
273 #include "clang/Basic/OpenMPKinds.def"
280 #define OPENMP_SIMD_CLAUSE(Name) \
283 #include "clang/Basic/OpenMPKinds.def"
290 #define OPENMP_FOR_CLAUSE(Name) \
293 #include "clang/Basic/OpenMPKinds.def"
300 #define OPENMP_FOR_SIMD_CLAUSE(Name) \
303 #include "clang/Basic/OpenMPKinds.def"
310 #define OPENMP_SECTIONS_CLAUSE(Name) \
313 #include "clang/Basic/OpenMPKinds.def"
320 #define OPENMP_SINGLE_CLAUSE(Name) \
323 #include "clang/Basic/OpenMPKinds.def"
328 case OMPD_parallel_for:
330 #define OPENMP_PARALLEL_FOR_CLAUSE(Name) \
333 #include "clang/Basic/OpenMPKinds.def"
338 case OMPD_parallel_for_simd:
340 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name) \
343 #include "clang/Basic/OpenMPKinds.def"
348 case OMPD_parallel_sections:
350 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name) \
353 #include "clang/Basic/OpenMPKinds.def"
360 #define OPENMP_TASK_CLAUSE(Name) \
363 #include "clang/Basic/OpenMPKinds.def"
369 return CKind == OMPC_flush;
373 #define OPENMP_ATOMIC_CLAUSE(Name) \
376 #include "clang/Basic/OpenMPKinds.def"
383 #define OPENMP_TARGET_CLAUSE(Name) \
386 #include "clang/Basic/OpenMPKinds.def"
391 case OMPD_target_data:
393 #define OPENMP_TARGET_DATA_CLAUSE(Name) \
396 #include "clang/Basic/OpenMPKinds.def"
403 #define OPENMP_TEAMS_CLAUSE(Name) \
406 #include "clang/Basic/OpenMPKinds.def"
413 #define OPENMP_CANCEL_CLAUSE(Name) \
416 #include "clang/Basic/OpenMPKinds.def"
423 #define OPENMP_ORDERED_CLAUSE(Name) \
426 #include "clang/Basic/OpenMPKinds.def"
433 #define OPENMP_TASKLOOP_CLAUSE(Name) \
436 #include "clang/Basic/OpenMPKinds.def"
441 case OMPD_taskloop_simd:
443 #define OPENMP_TASKLOOP_SIMD_CLAUSE(Name) \
446 #include "clang/Basic/OpenMPKinds.def"
453 #define OPENMP_CRITICAL_CLAUSE(Name) \
456 #include "clang/Basic/OpenMPKinds.def"
461 case OMPD_distribute:
463 #define OPENMP_DISTRIBUTE_CLAUSE(Name) \
466 #include "clang/Basic/OpenMPKinds.def"
472 case OMPD_threadprivate:
479 case OMPD_cancellation_point:
485 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
486 return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
487 DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
488 DKind == OMPD_taskloop ||
489 DKind == OMPD_taskloop_simd ||
490 DKind == OMPD_distribute; // TODO add next directives.
493 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
494 return DKind == OMPD_for || DKind == OMPD_for_simd ||
495 DKind == OMPD_sections || DKind == OMPD_section ||
496 DKind == OMPD_single || DKind == OMPD_parallel_for ||
497 DKind == OMPD_parallel_for_simd ||
498 DKind == OMPD_parallel_sections; // TODO add next directives.
501 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) {
502 return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd;
505 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
506 return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
507 DKind == OMPD_parallel_for_simd ||
508 DKind == OMPD_parallel_sections; // TODO add next directives.
511 bool clang::isOpenMPTargetDirective(OpenMPDirectiveKind DKind) {
512 return DKind == OMPD_target; // TODO add next directives.
515 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) {
516 return DKind == OMPD_teams; // TODO add next directives.
519 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
520 return DKind == OMPD_simd || DKind == OMPD_for_simd ||
521 DKind == OMPD_parallel_for_simd ||
522 DKind == OMPD_taskloop_simd; // TODO add next directives.
525 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) {
526 return Kind == OMPD_distribute; // TODO add next directives.
529 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
530 return Kind == OMPC_private || Kind == OMPC_firstprivate ||
531 Kind == OMPC_lastprivate || Kind == OMPC_linear ||
532 Kind == OMPC_reduction; // TODO add next clauses like 'reduction'.
535 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
536 return Kind == OMPC_threadprivate || Kind == OMPC_copyin;