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