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   // '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
52   // directive.
53   if (Str == "flush")
54     return OMPC_unknown;
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);
59 }
60 
61 const char *clang::getOpenMPClauseName(OpenMPClauseKind Kind) {
62   assert(Kind <= OMPC_unknown);
63   switch (Kind) {
64   case OMPC_unknown:
65     return "unknown";
66 #define OPENMP_CLAUSE(Name, Class)                                             \
67   case OMPC_##Name:                                                            \
68     return #Name;
69 #include "clang/Basic/OpenMPKinds.def"
70   case OMPC_threadprivate:
71     return "threadprivate or thread local";
72   }
73   llvm_unreachable("Invalid OpenMP clause kind");
74 }
75 
76 unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind,
77                                           StringRef Str) {
78   switch (Kind) {
79   case OMPC_default:
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);
84   case OMPC_proc_bind:
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);
89   case OMPC_schedule:
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);
94   case OMPC_depend:
95     return llvm::StringSwitch<OpenMPDependClauseKind>(Str)
96 #define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name)
97 #include "clang/Basic/OpenMPKinds.def"
98         .Default(OMPC_DEPEND_unknown);
99   case OMPC_linear:
100     return llvm::StringSwitch<OpenMPLinearClauseKind>(Str)
101 #define OPENMP_LINEAR_KIND(Name) .Case(#Name, OMPC_LINEAR_##Name)
102 #include "clang/Basic/OpenMPKinds.def"
103         .Default(OMPC_LINEAR_unknown);
104   case OMPC_unknown:
105   case OMPC_threadprivate:
106   case OMPC_if:
107   case OMPC_final:
108   case OMPC_num_threads:
109   case OMPC_safelen:
110   case OMPC_simdlen:
111   case OMPC_collapse:
112   case OMPC_private:
113   case OMPC_firstprivate:
114   case OMPC_lastprivate:
115   case OMPC_shared:
116   case OMPC_reduction:
117   case OMPC_aligned:
118   case OMPC_copyin:
119   case OMPC_copyprivate:
120   case OMPC_ordered:
121   case OMPC_nowait:
122   case OMPC_untied:
123   case OMPC_mergeable:
124   case OMPC_flush:
125   case OMPC_read:
126   case OMPC_write:
127   case OMPC_update:
128   case OMPC_capture:
129   case OMPC_seq_cst:
130   case OMPC_device:
131     break;
132   }
133   llvm_unreachable("Invalid OpenMP simple clause kind");
134 }
135 
136 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
137                                                  unsigned Type) {
138   switch (Kind) {
139   case OMPC_default:
140     switch (Type) {
141     case OMPC_DEFAULT_unknown:
142       return "unknown";
143 #define OPENMP_DEFAULT_KIND(Name)                                              \
144   case OMPC_DEFAULT_##Name:                                                    \
145     return #Name;
146 #include "clang/Basic/OpenMPKinds.def"
147     }
148     llvm_unreachable("Invalid OpenMP 'default' clause type");
149   case OMPC_proc_bind:
150     switch (Type) {
151     case OMPC_PROC_BIND_unknown:
152       return "unknown";
153 #define OPENMP_PROC_BIND_KIND(Name)                                            \
154   case OMPC_PROC_BIND_##Name:                                                  \
155     return #Name;
156 #include "clang/Basic/OpenMPKinds.def"
157     }
158     llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
159   case OMPC_schedule:
160     switch (Type) {
161     case OMPC_SCHEDULE_unknown:
162       return "unknown";
163 #define OPENMP_SCHEDULE_KIND(Name)                                             \
164   case OMPC_SCHEDULE_##Name:                                                   \
165     return #Name;
166 #include "clang/Basic/OpenMPKinds.def"
167     }
168   case OMPC_depend:
169     switch (Type) {
170     case OMPC_DEPEND_unknown:
171       return "unknown";
172 #define OPENMP_DEPEND_KIND(Name)                                             \
173   case OMPC_DEPEND_##Name:                                                   \
174     return #Name;
175 #include "clang/Basic/OpenMPKinds.def"
176     }
177     llvm_unreachable("Invalid OpenMP 'schedule' clause type");
178   case OMPC_linear:
179     switch (Type) {
180     case OMPC_LINEAR_unknown:
181       return "unknown";
182 #define OPENMP_LINEAR_KIND(Name)                                             \
183   case OMPC_LINEAR_##Name:                                                   \
184     return #Name;
185 #include "clang/Basic/OpenMPKinds.def"
186     }
187     llvm_unreachable("Invalid OpenMP 'linear' clause type");
188   case OMPC_unknown:
189   case OMPC_threadprivate:
190   case OMPC_if:
191   case OMPC_final:
192   case OMPC_num_threads:
193   case OMPC_safelen:
194   case OMPC_simdlen:
195   case OMPC_collapse:
196   case OMPC_private:
197   case OMPC_firstprivate:
198   case OMPC_lastprivate:
199   case OMPC_shared:
200   case OMPC_reduction:
201   case OMPC_aligned:
202   case OMPC_copyin:
203   case OMPC_copyprivate:
204   case OMPC_ordered:
205   case OMPC_nowait:
206   case OMPC_untied:
207   case OMPC_mergeable:
208   case OMPC_flush:
209   case OMPC_read:
210   case OMPC_write:
211   case OMPC_update:
212   case OMPC_capture:
213   case OMPC_seq_cst:
214   case OMPC_device:
215     break;
216   }
217   llvm_unreachable("Invalid OpenMP simple clause kind");
218 }
219 
220 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
221                                         OpenMPClauseKind CKind) {
222   assert(DKind <= OMPD_unknown);
223   assert(CKind <= OMPC_unknown);
224   switch (DKind) {
225   case OMPD_parallel:
226     switch (CKind) {
227 #define OPENMP_PARALLEL_CLAUSE(Name)                                           \
228   case OMPC_##Name:                                                            \
229     return true;
230 #include "clang/Basic/OpenMPKinds.def"
231     default:
232       break;
233     }
234     break;
235   case OMPD_simd:
236     switch (CKind) {
237 #define OPENMP_SIMD_CLAUSE(Name)                                               \
238   case OMPC_##Name:                                                            \
239     return true;
240 #include "clang/Basic/OpenMPKinds.def"
241     default:
242       break;
243     }
244     break;
245   case OMPD_for:
246     switch (CKind) {
247 #define OPENMP_FOR_CLAUSE(Name)                                                \
248   case OMPC_##Name:                                                            \
249     return true;
250 #include "clang/Basic/OpenMPKinds.def"
251     default:
252       break;
253     }
254     break;
255   case OMPD_for_simd:
256     switch (CKind) {
257 #define OPENMP_FOR_SIMD_CLAUSE(Name)                                           \
258   case OMPC_##Name:                                                            \
259     return true;
260 #include "clang/Basic/OpenMPKinds.def"
261     default:
262       break;
263     }
264     break;
265   case OMPD_sections:
266     switch (CKind) {
267 #define OPENMP_SECTIONS_CLAUSE(Name)                                           \
268   case OMPC_##Name:                                                            \
269     return true;
270 #include "clang/Basic/OpenMPKinds.def"
271     default:
272       break;
273     }
274     break;
275   case OMPD_single:
276     switch (CKind) {
277 #define OPENMP_SINGLE_CLAUSE(Name)                                             \
278   case OMPC_##Name:                                                            \
279     return true;
280 #include "clang/Basic/OpenMPKinds.def"
281     default:
282       break;
283     }
284     break;
285   case OMPD_parallel_for:
286     switch (CKind) {
287 #define OPENMP_PARALLEL_FOR_CLAUSE(Name)                                       \
288   case OMPC_##Name:                                                            \
289     return true;
290 #include "clang/Basic/OpenMPKinds.def"
291     default:
292       break;
293     }
294     break;
295   case OMPD_parallel_for_simd:
296     switch (CKind) {
297 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name)                                  \
298   case OMPC_##Name:                                                            \
299     return true;
300 #include "clang/Basic/OpenMPKinds.def"
301     default:
302       break;
303     }
304     break;
305   case OMPD_parallel_sections:
306     switch (CKind) {
307 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name)                                  \
308   case OMPC_##Name:                                                            \
309     return true;
310 #include "clang/Basic/OpenMPKinds.def"
311     default:
312       break;
313     }
314     break;
315   case OMPD_task:
316     switch (CKind) {
317 #define OPENMP_TASK_CLAUSE(Name)                                               \
318   case OMPC_##Name:                                                            \
319     return true;
320 #include "clang/Basic/OpenMPKinds.def"
321     default:
322       break;
323     }
324     break;
325   case OMPD_flush:
326     return CKind == OMPC_flush;
327     break;
328   case OMPD_atomic:
329     switch (CKind) {
330 #define OPENMP_ATOMIC_CLAUSE(Name)                                             \
331   case OMPC_##Name:                                                            \
332     return true;
333 #include "clang/Basic/OpenMPKinds.def"
334     default:
335       break;
336     }
337     break;
338   case OMPD_target:
339     switch (CKind) {
340 #define OPENMP_TARGET_CLAUSE(Name)                                             \
341   case OMPC_##Name:                                                            \
342     return true;
343 #include "clang/Basic/OpenMPKinds.def"
344     default:
345       break;
346     }
347     break;
348   case OMPD_target_data:
349     switch (CKind) {
350 #define OPENMP_TARGET_DATA_CLAUSE(Name)                                        \
351   case OMPC_##Name:                                                            \
352     return true;
353 #include "clang/Basic/OpenMPKinds.def"
354     default:
355       break;
356     }
357     break;
358   case OMPD_teams:
359     switch (CKind) {
360 #define OPENMP_TEAMS_CLAUSE(Name)                                              \
361   case OMPC_##Name:                                                            \
362     return true;
363 #include "clang/Basic/OpenMPKinds.def"
364     default:
365       break;
366     }
367     break;
368   case OMPD_unknown:
369   case OMPD_threadprivate:
370   case OMPD_section:
371   case OMPD_master:
372   case OMPD_critical:
373   case OMPD_taskyield:
374   case OMPD_barrier:
375   case OMPD_taskwait:
376   case OMPD_taskgroup:
377   case OMPD_cancellation_point:
378   case OMPD_cancel:
379   case OMPD_ordered:
380     break;
381   }
382   return false;
383 }
384 
385 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
386   return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
387          DKind == OMPD_parallel_for ||
388          DKind == OMPD_parallel_for_simd; // TODO add next directives.
389 }
390 
391 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
392   return DKind == OMPD_for || DKind == OMPD_for_simd ||
393          DKind == OMPD_sections || DKind == OMPD_section ||
394          DKind == OMPD_single || DKind == OMPD_parallel_for ||
395          DKind == OMPD_parallel_for_simd ||
396          DKind == OMPD_parallel_sections; // TODO add next directives.
397 }
398 
399 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
400   return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
401          DKind == OMPD_parallel_for_simd ||
402          DKind == OMPD_parallel_sections; // TODO add next directives.
403 }
404 
405 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) {
406   return DKind == OMPD_teams; // TODO add next directives.
407 }
408 
409 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
410   return DKind == OMPD_simd || DKind == OMPD_for_simd ||
411          DKind == OMPD_parallel_for_simd; // TODO add next directives.
412 }
413 
414 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
415   return Kind == OMPC_private || Kind == OMPC_firstprivate ||
416          Kind == OMPC_lastprivate || Kind == OMPC_linear ||
417          Kind == OMPC_reduction; // TODO add next clauses like 'reduction'.
418 }
419 
420 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
421   return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
422 }
423 
424