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