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_map:
105     return llvm::StringSwitch<OpenMPMapClauseKind>(Str)
106 #define OPENMP_MAP_KIND(Name) .Case(#Name, OMPC_MAP_##Name)
107 #include "clang/Basic/OpenMPKinds.def"
108         .Default(OMPC_MAP_unknown);
109   case OMPC_unknown:
110   case OMPC_threadprivate:
111   case OMPC_if:
112   case OMPC_final:
113   case OMPC_num_threads:
114   case OMPC_safelen:
115   case OMPC_simdlen:
116   case OMPC_collapse:
117   case OMPC_private:
118   case OMPC_firstprivate:
119   case OMPC_lastprivate:
120   case OMPC_shared:
121   case OMPC_reduction:
122   case OMPC_aligned:
123   case OMPC_copyin:
124   case OMPC_copyprivate:
125   case OMPC_ordered:
126   case OMPC_nowait:
127   case OMPC_untied:
128   case OMPC_mergeable:
129   case OMPC_flush:
130   case OMPC_read:
131   case OMPC_write:
132   case OMPC_update:
133   case OMPC_capture:
134   case OMPC_seq_cst:
135   case OMPC_device:
136   case OMPC_threads:
137   case OMPC_simd:
138   case OMPC_num_teams:
139   case OMPC_thread_limit:
140   case OMPC_priority:
141   case OMPC_grainsize:
142   case OMPC_nogroup:
143     break;
144   }
145   llvm_unreachable("Invalid OpenMP simple clause kind");
146 }
147 
148 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
149                                                  unsigned Type) {
150   switch (Kind) {
151   case OMPC_default:
152     switch (Type) {
153     case OMPC_DEFAULT_unknown:
154       return "unknown";
155 #define OPENMP_DEFAULT_KIND(Name)                                              \
156   case OMPC_DEFAULT_##Name:                                                    \
157     return #Name;
158 #include "clang/Basic/OpenMPKinds.def"
159     }
160     llvm_unreachable("Invalid OpenMP 'default' clause type");
161   case OMPC_proc_bind:
162     switch (Type) {
163     case OMPC_PROC_BIND_unknown:
164       return "unknown";
165 #define OPENMP_PROC_BIND_KIND(Name)                                            \
166   case OMPC_PROC_BIND_##Name:                                                  \
167     return #Name;
168 #include "clang/Basic/OpenMPKinds.def"
169     }
170     llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
171   case OMPC_schedule:
172     switch (Type) {
173     case OMPC_SCHEDULE_unknown:
174       return "unknown";
175 #define OPENMP_SCHEDULE_KIND(Name)                                             \
176   case OMPC_SCHEDULE_##Name:                                                   \
177     return #Name;
178 #include "clang/Basic/OpenMPKinds.def"
179     }
180   case OMPC_depend:
181     switch (Type) {
182     case OMPC_DEPEND_unknown:
183       return "unknown";
184 #define OPENMP_DEPEND_KIND(Name)                                             \
185   case OMPC_DEPEND_##Name:                                                   \
186     return #Name;
187 #include "clang/Basic/OpenMPKinds.def"
188     }
189     llvm_unreachable("Invalid OpenMP 'schedule' clause type");
190   case OMPC_linear:
191     switch (Type) {
192     case OMPC_LINEAR_unknown:
193       return "unknown";
194 #define OPENMP_LINEAR_KIND(Name)                                             \
195   case OMPC_LINEAR_##Name:                                                   \
196     return #Name;
197 #include "clang/Basic/OpenMPKinds.def"
198     }
199     llvm_unreachable("Invalid OpenMP 'linear' clause type");
200   case OMPC_map:
201     switch (Type) {
202     case OMPC_MAP_unknown:
203       return "unknown";
204 #define OPENMP_MAP_KIND(Name)                                                \
205   case OMPC_MAP_##Name:                                                      \
206     return #Name;
207 #include "clang/Basic/OpenMPKinds.def"
208     default:
209       break;
210     }
211     llvm_unreachable("Invalid OpenMP 'map' clause type");
212   case OMPC_unknown:
213   case OMPC_threadprivate:
214   case OMPC_if:
215   case OMPC_final:
216   case OMPC_num_threads:
217   case OMPC_safelen:
218   case OMPC_simdlen:
219   case OMPC_collapse:
220   case OMPC_private:
221   case OMPC_firstprivate:
222   case OMPC_lastprivate:
223   case OMPC_shared:
224   case OMPC_reduction:
225   case OMPC_aligned:
226   case OMPC_copyin:
227   case OMPC_copyprivate:
228   case OMPC_ordered:
229   case OMPC_nowait:
230   case OMPC_untied:
231   case OMPC_mergeable:
232   case OMPC_flush:
233   case OMPC_read:
234   case OMPC_write:
235   case OMPC_update:
236   case OMPC_capture:
237   case OMPC_seq_cst:
238   case OMPC_device:
239   case OMPC_threads:
240   case OMPC_simd:
241   case OMPC_num_teams:
242   case OMPC_thread_limit:
243   case OMPC_priority:
244   case OMPC_grainsize:
245   case OMPC_nogroup:
246     break;
247   }
248   llvm_unreachable("Invalid OpenMP simple clause kind");
249 }
250 
251 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
252                                         OpenMPClauseKind CKind) {
253   assert(DKind <= OMPD_unknown);
254   assert(CKind <= OMPC_unknown);
255   switch (DKind) {
256   case OMPD_parallel:
257     switch (CKind) {
258 #define OPENMP_PARALLEL_CLAUSE(Name)                                           \
259   case OMPC_##Name:                                                            \
260     return true;
261 #include "clang/Basic/OpenMPKinds.def"
262     default:
263       break;
264     }
265     break;
266   case OMPD_simd:
267     switch (CKind) {
268 #define OPENMP_SIMD_CLAUSE(Name)                                               \
269   case OMPC_##Name:                                                            \
270     return true;
271 #include "clang/Basic/OpenMPKinds.def"
272     default:
273       break;
274     }
275     break;
276   case OMPD_for:
277     switch (CKind) {
278 #define OPENMP_FOR_CLAUSE(Name)                                                \
279   case OMPC_##Name:                                                            \
280     return true;
281 #include "clang/Basic/OpenMPKinds.def"
282     default:
283       break;
284     }
285     break;
286   case OMPD_for_simd:
287     switch (CKind) {
288 #define OPENMP_FOR_SIMD_CLAUSE(Name)                                           \
289   case OMPC_##Name:                                                            \
290     return true;
291 #include "clang/Basic/OpenMPKinds.def"
292     default:
293       break;
294     }
295     break;
296   case OMPD_sections:
297     switch (CKind) {
298 #define OPENMP_SECTIONS_CLAUSE(Name)                                           \
299   case OMPC_##Name:                                                            \
300     return true;
301 #include "clang/Basic/OpenMPKinds.def"
302     default:
303       break;
304     }
305     break;
306   case OMPD_single:
307     switch (CKind) {
308 #define OPENMP_SINGLE_CLAUSE(Name)                                             \
309   case OMPC_##Name:                                                            \
310     return true;
311 #include "clang/Basic/OpenMPKinds.def"
312     default:
313       break;
314     }
315     break;
316   case OMPD_parallel_for:
317     switch (CKind) {
318 #define OPENMP_PARALLEL_FOR_CLAUSE(Name)                                       \
319   case OMPC_##Name:                                                            \
320     return true;
321 #include "clang/Basic/OpenMPKinds.def"
322     default:
323       break;
324     }
325     break;
326   case OMPD_parallel_for_simd:
327     switch (CKind) {
328 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name)                                  \
329   case OMPC_##Name:                                                            \
330     return true;
331 #include "clang/Basic/OpenMPKinds.def"
332     default:
333       break;
334     }
335     break;
336   case OMPD_parallel_sections:
337     switch (CKind) {
338 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name)                                  \
339   case OMPC_##Name:                                                            \
340     return true;
341 #include "clang/Basic/OpenMPKinds.def"
342     default:
343       break;
344     }
345     break;
346   case OMPD_task:
347     switch (CKind) {
348 #define OPENMP_TASK_CLAUSE(Name)                                               \
349   case OMPC_##Name:                                                            \
350     return true;
351 #include "clang/Basic/OpenMPKinds.def"
352     default:
353       break;
354     }
355     break;
356   case OMPD_flush:
357     return CKind == OMPC_flush;
358     break;
359   case OMPD_atomic:
360     switch (CKind) {
361 #define OPENMP_ATOMIC_CLAUSE(Name)                                             \
362   case OMPC_##Name:                                                            \
363     return true;
364 #include "clang/Basic/OpenMPKinds.def"
365     default:
366       break;
367     }
368     break;
369   case OMPD_target:
370     switch (CKind) {
371 #define OPENMP_TARGET_CLAUSE(Name)                                             \
372   case OMPC_##Name:                                                            \
373     return true;
374 #include "clang/Basic/OpenMPKinds.def"
375     default:
376       break;
377     }
378     break;
379   case OMPD_target_data:
380     switch (CKind) {
381 #define OPENMP_TARGET_DATA_CLAUSE(Name)                                        \
382   case OMPC_##Name:                                                            \
383     return true;
384 #include "clang/Basic/OpenMPKinds.def"
385     default:
386       break;
387     }
388     break;
389   case OMPD_teams:
390     switch (CKind) {
391 #define OPENMP_TEAMS_CLAUSE(Name)                                              \
392   case OMPC_##Name:                                                            \
393     return true;
394 #include "clang/Basic/OpenMPKinds.def"
395     default:
396       break;
397     }
398     break;
399   case OMPD_cancel:
400     switch (CKind) {
401 #define OPENMP_CANCEL_CLAUSE(Name)                                             \
402   case OMPC_##Name:                                                            \
403     return true;
404 #include "clang/Basic/OpenMPKinds.def"
405     default:
406       break;
407     }
408     break;
409   case OMPD_ordered:
410     switch (CKind) {
411 #define OPENMP_ORDERED_CLAUSE(Name)                                            \
412   case OMPC_##Name:                                                            \
413     return true;
414 #include "clang/Basic/OpenMPKinds.def"
415     default:
416       break;
417     }
418     break;
419   case OMPD_taskloop:
420     switch (CKind) {
421 #define OPENMP_TASKLOOP_CLAUSE(Name)                                           \
422   case OMPC_##Name:                                                            \
423     return true;
424 #include "clang/Basic/OpenMPKinds.def"
425     default:
426       break;
427     }
428     break;
429   case OMPD_taskloop_simd:
430     switch (CKind) {
431 #define OPENMP_TASKLOOP_SIMD_CLAUSE(Name)                                      \
432   case OMPC_##Name:                                                            \
433     return true;
434 #include "clang/Basic/OpenMPKinds.def"
435     default:
436       break;
437     }
438     break;
439   case OMPD_unknown:
440   case OMPD_threadprivate:
441   case OMPD_section:
442   case OMPD_master:
443   case OMPD_critical:
444   case OMPD_taskyield:
445   case OMPD_barrier:
446   case OMPD_taskwait:
447   case OMPD_taskgroup:
448   case OMPD_cancellation_point:
449     break;
450   }
451   return false;
452 }
453 
454 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
455   return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
456          DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
457          DKind == OMPD_taskloop ||
458          DKind == OMPD_taskloop_simd; // TODO add next directives.
459 }
460 
461 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
462   return DKind == OMPD_for || DKind == OMPD_for_simd ||
463          DKind == OMPD_sections || DKind == OMPD_section ||
464          DKind == OMPD_single || DKind == OMPD_parallel_for ||
465          DKind == OMPD_parallel_for_simd ||
466          DKind == OMPD_parallel_sections; // TODO add next directives.
467 }
468 
469 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) {
470   return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd;
471 }
472 
473 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
474   return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
475          DKind == OMPD_parallel_for_simd ||
476          DKind == OMPD_parallel_sections; // TODO add next directives.
477 }
478 
479 bool clang::isOpenMPTargetDirective(OpenMPDirectiveKind DKind) {
480   return DKind == OMPD_target; // TODO add next directives.
481 }
482 
483 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) {
484   return DKind == OMPD_teams; // TODO add next directives.
485 }
486 
487 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
488   return DKind == OMPD_simd || DKind == OMPD_for_simd ||
489          DKind == OMPD_parallel_for_simd ||
490          DKind == OMPD_taskloop_simd; // TODO add next directives.
491 }
492 
493 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
494   return Kind == OMPC_private || Kind == OMPC_firstprivate ||
495          Kind == OMPC_lastprivate || Kind == OMPC_linear ||
496          Kind == OMPC_reduction; // TODO add next clauses like 'reduction'.
497 }
498 
499 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
500   return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
501 }
502 
503