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   case OMPC_read:
112   case OMPC_write:
113   case OMPC_update:
114   case OMPC_capture:
115   case OMPC_seq_cst:
116     break;
117   }
118   llvm_unreachable("Invalid OpenMP simple clause kind");
119 }
120 
121 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
122                                                  unsigned Type) {
123   switch (Kind) {
124   case OMPC_default:
125     switch (Type) {
126     case OMPC_DEFAULT_unknown:
127       return "unknown";
128 #define OPENMP_DEFAULT_KIND(Name)                                              \
129   case OMPC_DEFAULT_##Name:                                                    \
130     return #Name;
131 #include "clang/Basic/OpenMPKinds.def"
132     }
133     llvm_unreachable("Invalid OpenMP 'default' clause type");
134   case OMPC_proc_bind:
135     switch (Type) {
136     case OMPC_PROC_BIND_unknown:
137       return "unknown";
138 #define OPENMP_PROC_BIND_KIND(Name)                                            \
139   case OMPC_PROC_BIND_##Name:                                                  \
140     return #Name;
141 #include "clang/Basic/OpenMPKinds.def"
142     }
143     llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
144   case OMPC_schedule:
145     switch (Type) {
146     case OMPC_SCHEDULE_unknown:
147       return "unknown";
148 #define OPENMP_SCHEDULE_KIND(Name)                                             \
149   case OMPC_SCHEDULE_##Name:                                                   \
150     return #Name;
151 #include "clang/Basic/OpenMPKinds.def"
152     }
153     llvm_unreachable("Invalid OpenMP 'schedule' clause type");
154   case OMPC_unknown:
155   case OMPC_threadprivate:
156   case OMPC_if:
157   case OMPC_final:
158   case OMPC_num_threads:
159   case OMPC_safelen:
160   case OMPC_collapse:
161   case OMPC_private:
162   case OMPC_firstprivate:
163   case OMPC_lastprivate:
164   case OMPC_shared:
165   case OMPC_reduction:
166   case OMPC_linear:
167   case OMPC_aligned:
168   case OMPC_copyin:
169   case OMPC_copyprivate:
170   case OMPC_ordered:
171   case OMPC_nowait:
172   case OMPC_untied:
173   case OMPC_mergeable:
174   case OMPC_flush:
175   case OMPC_read:
176   case OMPC_write:
177   case OMPC_update:
178   case OMPC_capture:
179   case OMPC_seq_cst:
180     break;
181   }
182   llvm_unreachable("Invalid OpenMP simple clause kind");
183 }
184 
185 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
186                                         OpenMPClauseKind CKind) {
187   assert(DKind <= OMPD_unknown);
188   assert(CKind <= OMPC_unknown);
189   switch (DKind) {
190   case OMPD_parallel:
191     switch (CKind) {
192 #define OPENMP_PARALLEL_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_simd:
201     switch (CKind) {
202 #define OPENMP_SIMD_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_for:
211     switch (CKind) {
212 #define OPENMP_FOR_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_sections:
221     switch (CKind) {
222 #define OPENMP_SECTIONS_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_single:
231     switch (CKind) {
232 #define OPENMP_SINGLE_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_for:
241     switch (CKind) {
242 #define OPENMP_PARALLEL_FOR_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_parallel_sections:
251     switch (CKind) {
252 #define OPENMP_PARALLEL_SECTIONS_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_task:
261     switch (CKind) {
262 #define OPENMP_TASK_CLAUSE(Name)                                               \
263   case OMPC_##Name:                                                            \
264     return true;
265 #include "clang/Basic/OpenMPKinds.def"
266     default:
267       break;
268     }
269     break;
270   case OMPD_flush:
271     return CKind == OMPC_flush;
272     break;
273   case OMPD_atomic:
274     switch (CKind) {
275 #define OPENMP_ATOMIC_CLAUSE(Name)                                             \
276   case OMPC_##Name:                                                            \
277     return true;
278 #include "clang/Basic/OpenMPKinds.def"
279     default:
280       break;
281     }
282     break;
283   case OMPD_unknown:
284   case OMPD_threadprivate:
285   case OMPD_section:
286   case OMPD_master:
287   case OMPD_critical:
288   case OMPD_taskyield:
289   case OMPD_barrier:
290   case OMPD_taskwait:
291   case OMPD_ordered:
292     break;
293   }
294   return false;
295 }
296 
297 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
298   return DKind == OMPD_simd || DKind == OMPD_for ||
299          DKind == OMPD_parallel_for; // TODO add next directives.
300 }
301 
302 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
303   return DKind == OMPD_for || DKind == OMPD_sections || DKind == OMPD_section ||
304          DKind == OMPD_single || DKind == OMPD_parallel_for ||
305          DKind == OMPD_parallel_sections; // TODO add next directives.
306 }
307 
308 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
309   return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
310          DKind == OMPD_parallel_sections; // TODO add next directives.
311 }
312 
313 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
314   return DKind == OMPD_simd; // TODO || DKind == OMPD_for_simd || ...
315 }
316 
317 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
318   return Kind == OMPC_private || Kind == OMPC_firstprivate ||
319          Kind == OMPC_lastprivate || Kind == OMPC_linear ||
320          Kind == OMPC_reduction; // TODO add next clauses like 'reduction'.
321 }
322 
323 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
324   return Kind == OMPC_threadprivate ||
325          Kind == OMPC_copyin; // TODO add next clauses like 'copyprivate'.
326 }
327 
328