1 //===--- OpenMPKinds.cpp - Token Kinds Support ----------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 /// \file
10 /// \brief This file implements the OpenMP enum and support functions.
11 ///
12 //===----------------------------------------------------------------------===//
13 
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"
19 #include <cassert>
20 
21 using namespace clang;
22 
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);
29 }
30 
31 const char *clang::getOpenMPDirectiveName(OpenMPDirectiveKind Kind) {
32   assert(Kind <= OMPD_unknown);
33   switch (Kind) {
34   case OMPD_unknown:
35     return "unknown";
36 #define OPENMP_DIRECTIVE(Name)                                                 \
37   case OMPD_##Name:                                                            \
38     return #Name;
39 #define OPENMP_DIRECTIVE_EXT(Name, Str)                                        \
40   case OMPD_##Name:                                                            \
41     return Str;
42 #include "clang/Basic/OpenMPKinds.def"
43     break;
44   }
45   llvm_unreachable("Invalid OpenMP directive kind");
46 }
47 
48 OpenMPClauseKind clang::getOpenMPClauseKind(StringRef Str) {
49   if (Str == "flush")
50     return OMPC_unknown;
51   return llvm::StringSwitch<OpenMPClauseKind>(Str)
52 #define OPENMP_CLAUSE(Name, Class) .Case(#Name, OMPC_##Name)
53 #include "clang/Basic/OpenMPKinds.def"
54       .Default(OMPC_unknown);
55 }
56 
57 const char *clang::getOpenMPClauseName(OpenMPClauseKind Kind) {
58   assert(Kind <= OMPC_unknown);
59   switch (Kind) {
60   case OMPC_unknown:
61     return "unknown";
62 #define OPENMP_CLAUSE(Name, Class)                                             \
63   case OMPC_##Name:                                                            \
64     return #Name;
65 #include "clang/Basic/OpenMPKinds.def"
66   case OMPC_threadprivate:
67     return "threadprivate or thread local";
68   }
69   llvm_unreachable("Invalid OpenMP clause kind");
70 }
71 
72 unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind,
73                                           StringRef Str) {
74   switch (Kind) {
75   case OMPC_default:
76     return llvm::StringSwitch<OpenMPDefaultClauseKind>(Str)
77 #define OPENMP_DEFAULT_KIND(Name) .Case(#Name, OMPC_DEFAULT_##Name)
78 #include "clang/Basic/OpenMPKinds.def"
79         .Default(OMPC_DEFAULT_unknown);
80   case OMPC_proc_bind:
81     return llvm::StringSwitch<OpenMPProcBindClauseKind>(Str)
82 #define OPENMP_PROC_BIND_KIND(Name) .Case(#Name, OMPC_PROC_BIND_##Name)
83 #include "clang/Basic/OpenMPKinds.def"
84         .Default(OMPC_PROC_BIND_unknown);
85   case OMPC_schedule:
86     return llvm::StringSwitch<OpenMPScheduleClauseKind>(Str)
87 #define OPENMP_SCHEDULE_KIND(Name) .Case(#Name, OMPC_SCHEDULE_##Name)
88 #include "clang/Basic/OpenMPKinds.def"
89         .Default(OMPC_SCHEDULE_unknown);
90   case OMPC_unknown:
91   case OMPC_threadprivate:
92   case OMPC_if:
93   case OMPC_final:
94   case OMPC_num_threads:
95   case OMPC_safelen:
96   case OMPC_collapse:
97   case OMPC_private:
98   case OMPC_firstprivate:
99   case OMPC_lastprivate:
100   case OMPC_shared:
101   case OMPC_reduction:
102   case OMPC_linear:
103   case OMPC_aligned:
104   case OMPC_copyin:
105   case OMPC_copyprivate:
106   case OMPC_ordered:
107   case OMPC_nowait:
108   case OMPC_untied:
109   case OMPC_mergeable:
110   case OMPC_flush:
111     break;
112   }
113   llvm_unreachable("Invalid OpenMP simple clause kind");
114 }
115 
116 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
117                                                  unsigned Type) {
118   switch (Kind) {
119   case OMPC_default:
120     switch (Type) {
121     case OMPC_DEFAULT_unknown:
122       return "unknown";
123 #define OPENMP_DEFAULT_KIND(Name)                                              \
124   case OMPC_DEFAULT_##Name:                                                    \
125     return #Name;
126 #include "clang/Basic/OpenMPKinds.def"
127     }
128     llvm_unreachable("Invalid OpenMP 'default' clause type");
129   case OMPC_proc_bind:
130     switch (Type) {
131     case OMPC_PROC_BIND_unknown:
132       return "unknown";
133 #define OPENMP_PROC_BIND_KIND(Name)                                            \
134   case OMPC_PROC_BIND_##Name:                                                  \
135     return #Name;
136 #include "clang/Basic/OpenMPKinds.def"
137     }
138     llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
139   case OMPC_schedule:
140     switch (Type) {
141     case OMPC_SCHEDULE_unknown:
142       return "unknown";
143 #define OPENMP_SCHEDULE_KIND(Name)                                             \
144   case OMPC_SCHEDULE_##Name:                                                   \
145     return #Name;
146 #include "clang/Basic/OpenMPKinds.def"
147     }
148     llvm_unreachable("Invalid OpenMP 'schedule' clause type");
149   case OMPC_unknown:
150   case OMPC_threadprivate:
151   case OMPC_if:
152   case OMPC_final:
153   case OMPC_num_threads:
154   case OMPC_safelen:
155   case OMPC_collapse:
156   case OMPC_private:
157   case OMPC_firstprivate:
158   case OMPC_lastprivate:
159   case OMPC_shared:
160   case OMPC_reduction:
161   case OMPC_linear:
162   case OMPC_aligned:
163   case OMPC_copyin:
164   case OMPC_copyprivate:
165   case OMPC_ordered:
166   case OMPC_nowait:
167   case OMPC_untied:
168   case OMPC_mergeable:
169   case OMPC_flush:
170     break;
171   }
172   llvm_unreachable("Invalid OpenMP simple clause kind");
173 }
174 
175 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
176                                         OpenMPClauseKind CKind) {
177   assert(DKind <= OMPD_unknown);
178   assert(CKind <= OMPC_unknown);
179   switch (DKind) {
180   case OMPD_parallel:
181     switch (CKind) {
182 #define OPENMP_PARALLEL_CLAUSE(Name)                                           \
183   case OMPC_##Name:                                                            \
184     return true;
185 #include "clang/Basic/OpenMPKinds.def"
186     default:
187       break;
188     }
189     break;
190   case OMPD_simd:
191     switch (CKind) {
192 #define OPENMP_SIMD_CLAUSE(Name)                                               \
193   case OMPC_##Name:                                                            \
194     return true;
195 #include "clang/Basic/OpenMPKinds.def"
196     default:
197       break;
198     }
199     break;
200   case OMPD_for:
201     switch (CKind) {
202 #define OPENMP_FOR_CLAUSE(Name)                                                \
203   case OMPC_##Name:                                                            \
204     return true;
205 #include "clang/Basic/OpenMPKinds.def"
206     default:
207       break;
208     }
209     break;
210   case OMPD_sections:
211     switch (CKind) {
212 #define OPENMP_SECTIONS_CLAUSE(Name)                                           \
213   case OMPC_##Name:                                                            \
214     return true;
215 #include "clang/Basic/OpenMPKinds.def"
216     default:
217       break;
218     }
219     break;
220   case OMPD_single:
221     switch (CKind) {
222 #define OPENMP_SINGLE_CLAUSE(Name)                                             \
223   case OMPC_##Name:                                                            \
224     return true;
225 #include "clang/Basic/OpenMPKinds.def"
226     default:
227       break;
228     }
229     break;
230   case OMPD_parallel_for:
231     switch (CKind) {
232 #define OPENMP_PARALLEL_FOR_CLAUSE(Name)                                       \
233   case OMPC_##Name:                                                            \
234     return true;
235 #include "clang/Basic/OpenMPKinds.def"
236     default:
237       break;
238     }
239     break;
240   case OMPD_parallel_sections:
241     switch (CKind) {
242 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name)                                  \
243   case OMPC_##Name:                                                            \
244     return true;
245 #include "clang/Basic/OpenMPKinds.def"
246     default:
247       break;
248     }
249     break;
250   case OMPD_task:
251     switch (CKind) {
252 #define OPENMP_TASK_CLAUSE(Name)                                               \
253   case OMPC_##Name:                                                            \
254     return true;
255 #include "clang/Basic/OpenMPKinds.def"
256     default:
257       break;
258     }
259     break;
260   case OMPD_flush:
261     return CKind == OMPC_flush;
262     break;
263   case OMPD_unknown:
264   case OMPD_threadprivate:
265   case OMPD_section:
266   case OMPD_master:
267   case OMPD_critical:
268   case OMPD_taskyield:
269   case OMPD_barrier:
270   case OMPD_taskwait:
271     break;
272   }
273   return false;
274 }
275 
276 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
277   return DKind == OMPD_simd || DKind == OMPD_for ||
278          DKind == OMPD_parallel_for; // TODO add next directives.
279 }
280 
281 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
282   return DKind == OMPD_for || DKind == OMPD_sections || DKind == OMPD_section ||
283          DKind == OMPD_single || DKind == OMPD_parallel_for ||
284          DKind == OMPD_parallel_sections; // TODO add next directives.
285 }
286 
287 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
288   return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
289          DKind == OMPD_parallel_sections; // TODO add next directives.
290 }
291 
292 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
293   return DKind == OMPD_simd; // TODO || DKind == OMPD_for_simd || ...
294 }
295 
296 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
297   return Kind == OMPC_private || Kind == OMPC_firstprivate ||
298          Kind == OMPC_lastprivate || Kind == OMPC_linear ||
299          Kind == OMPC_reduction; // TODO add next clauses like 'reduction'.
300 }
301 
302 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
303   return Kind == OMPC_threadprivate ||
304          Kind == OMPC_copyin; // TODO add next clauses like 'copyprivate'.
305 }
306 
307