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<OpenMPScheduleClauseKind>(Str)
91 #define OPENMP_SCHEDULE_KIND(Name) .Case(#Name, OMPC_SCHEDULE_##Name)
92 #include "clang/Basic/OpenMPKinds.def"
93 .Default(OMPC_SCHEDULE_unknown);
95 case OMPC_threadprivate:
98 case OMPC_num_threads:
102 case OMPC_firstprivate:
103 case OMPC_lastprivate:
109 case OMPC_copyprivate:
122 llvm_unreachable("Invalid OpenMP simple clause kind");
125 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
130 case OMPC_DEFAULT_unknown:
132 #define OPENMP_DEFAULT_KIND(Name) \
133 case OMPC_DEFAULT_##Name: \
135 #include "clang/Basic/OpenMPKinds.def"
137 llvm_unreachable("Invalid OpenMP 'default' clause type");
140 case OMPC_PROC_BIND_unknown:
142 #define OPENMP_PROC_BIND_KIND(Name) \
143 case OMPC_PROC_BIND_##Name: \
145 #include "clang/Basic/OpenMPKinds.def"
147 llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
150 case OMPC_SCHEDULE_unknown:
152 #define OPENMP_SCHEDULE_KIND(Name) \
153 case OMPC_SCHEDULE_##Name: \
155 #include "clang/Basic/OpenMPKinds.def"
157 llvm_unreachable("Invalid OpenMP 'schedule' clause type");
159 case OMPC_threadprivate:
162 case OMPC_num_threads:
166 case OMPC_firstprivate:
167 case OMPC_lastprivate:
173 case OMPC_copyprivate:
186 llvm_unreachable("Invalid OpenMP simple clause kind");
189 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
190 OpenMPClauseKind CKind) {
191 assert(DKind <= OMPD_unknown);
192 assert(CKind <= OMPC_unknown);
196 #define OPENMP_PARALLEL_CLAUSE(Name) \
199 #include "clang/Basic/OpenMPKinds.def"
206 #define OPENMP_SIMD_CLAUSE(Name) \
209 #include "clang/Basic/OpenMPKinds.def"
216 #define OPENMP_FOR_CLAUSE(Name) \
219 #include "clang/Basic/OpenMPKinds.def"
226 #define OPENMP_FOR_SIMD_CLAUSE(Name) \
229 #include "clang/Basic/OpenMPKinds.def"
236 #define OPENMP_SECTIONS_CLAUSE(Name) \
239 #include "clang/Basic/OpenMPKinds.def"
246 #define OPENMP_SINGLE_CLAUSE(Name) \
249 #include "clang/Basic/OpenMPKinds.def"
254 case OMPD_parallel_for:
256 #define OPENMP_PARALLEL_FOR_CLAUSE(Name) \
259 #include "clang/Basic/OpenMPKinds.def"
264 case OMPD_parallel_for_simd:
266 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name) \
269 #include "clang/Basic/OpenMPKinds.def"
274 case OMPD_parallel_sections:
276 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name) \
279 #include "clang/Basic/OpenMPKinds.def"
286 #define OPENMP_TASK_CLAUSE(Name) \
289 #include "clang/Basic/OpenMPKinds.def"
295 return CKind == OMPC_flush;
299 #define OPENMP_ATOMIC_CLAUSE(Name) \
302 #include "clang/Basic/OpenMPKinds.def"
309 #define OPENMP_TARGET_CLAUSE(Name) \
312 #include "clang/Basic/OpenMPKinds.def"
319 #define OPENMP_TEAMS_CLAUSE(Name) \
322 #include "clang/Basic/OpenMPKinds.def"
328 case OMPD_threadprivate:
341 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
342 return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
343 DKind == OMPD_parallel_for ||
344 DKind == OMPD_parallel_for_simd; // TODO add next directives.
347 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
348 return DKind == OMPD_for || DKind == OMPD_for_simd ||
349 DKind == OMPD_sections || DKind == OMPD_section ||
350 DKind == OMPD_single || DKind == OMPD_parallel_for ||
351 DKind == OMPD_parallel_for_simd ||
352 DKind == OMPD_parallel_sections; // TODO add next directives.
355 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
356 return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
357 DKind == OMPD_parallel_for_simd ||
358 DKind == OMPD_parallel_sections; // TODO add next directives.
361 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) {
362 return DKind == OMPD_teams; // TODO add next directives.
365 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
366 return DKind == OMPD_simd || DKind == OMPD_for_simd ||
367 DKind == OMPD_parallel_for_simd; // TODO add next directives.
370 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
371 return Kind == OMPC_private || Kind == OMPC_firstprivate ||
372 Kind == OMPC_lastprivate || Kind == OMPC_linear ||
373 Kind == OMPC_reduction; // TODO add next clauses like 'reduction'.
376 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
377 return Kind == OMPC_threadprivate || Kind == OMPC_copyin;