1 //===--- OpenMPKinds.cpp - Token Kinds Support ----------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 /// \file
9 /// This file implements the OpenMP enum and support functions.
10 ///
11 //===----------------------------------------------------------------------===//
12 
13 #include "clang/Basic/OpenMPKinds.h"
14 #include "clang/Basic/IdentifierTable.h"
15 #include "llvm/ADT/StringRef.h"
16 #include "llvm/ADT/StringSwitch.h"
17 #include "llvm/Support/ErrorHandling.h"
18 #include <cassert>
19 
20 using namespace clang;
21 
22 OpenMPDirectiveKind clang::getOpenMPDirectiveKind(StringRef Str) {
23   return llvm::StringSwitch<OpenMPDirectiveKind>(Str)
24 #define OPENMP_DIRECTIVE(Name) .Case(#Name, OMPD_##Name)
25 #define OPENMP_DIRECTIVE_EXT(Name, Str) .Case(Str, OMPD_##Name)
26 #include "clang/Basic/OpenMPKinds.def"
27       .Default(OMPD_unknown);
28 }
29 
30 const char *clang::getOpenMPDirectiveName(OpenMPDirectiveKind Kind) {
31   assert(Kind <= OMPD_unknown);
32   switch (Kind) {
33   case OMPD_unknown:
34     return "unknown";
35 #define OPENMP_DIRECTIVE(Name)                                                 \
36   case OMPD_##Name:                                                            \
37     return #Name;
38 #define OPENMP_DIRECTIVE_EXT(Name, Str)                                        \
39   case OMPD_##Name:                                                            \
40     return Str;
41 #include "clang/Basic/OpenMPKinds.def"
42     break;
43   }
44   llvm_unreachable("Invalid OpenMP directive kind");
45 }
46 
47 OpenMPClauseKind clang::getOpenMPClauseKind(StringRef Str) {
48   // 'flush' clause cannot be specified explicitly, because this is an implicit
49   // clause for 'flush' directive. If the 'flush' clause is explicitly specified
50   // the Parser should generate a warning about extra tokens at the end of the
51   // directive.
52   if (Str == "flush")
53     return OMPC_unknown;
54   return llvm::StringSwitch<OpenMPClauseKind>(Str)
55 #define OPENMP_CLAUSE(Name, Class) .Case(#Name, OMPC_##Name)
56 #include "clang/Basic/OpenMPKinds.def"
57       .Case("uniform", OMPC_uniform)
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_flush:
71     return "flush";
72   case OMPC_uniform:
73     return "uniform";
74   case OMPC_threadprivate:
75     return "threadprivate or thread local";
76   }
77   llvm_unreachable("Invalid OpenMP clause kind");
78 }
79 
80 unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind,
81                                           StringRef Str) {
82   switch (Kind) {
83   case OMPC_default:
84     return llvm::StringSwitch<OpenMPDefaultClauseKind>(Str)
85 #define OPENMP_DEFAULT_KIND(Name) .Case(#Name, OMPC_DEFAULT_##Name)
86 #include "clang/Basic/OpenMPKinds.def"
87         .Default(OMPC_DEFAULT_unknown);
88   case OMPC_proc_bind:
89     return llvm::StringSwitch<OpenMPProcBindClauseKind>(Str)
90 #define OPENMP_PROC_BIND_KIND(Name) .Case(#Name, OMPC_PROC_BIND_##Name)
91 #include "clang/Basic/OpenMPKinds.def"
92         .Default(OMPC_PROC_BIND_unknown);
93   case OMPC_schedule:
94     return llvm::StringSwitch<unsigned>(Str)
95 #define OPENMP_SCHEDULE_KIND(Name)                                             \
96   .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_##Name))
97 #define OPENMP_SCHEDULE_MODIFIER(Name)                                         \
98   .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_MODIFIER_##Name))
99 #include "clang/Basic/OpenMPKinds.def"
100         .Default(OMPC_SCHEDULE_unknown);
101   case OMPC_depend:
102     return llvm::StringSwitch<OpenMPDependClauseKind>(Str)
103 #define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name)
104 #include "clang/Basic/OpenMPKinds.def"
105         .Default(OMPC_DEPEND_unknown);
106   case OMPC_linear:
107     return llvm::StringSwitch<OpenMPLinearClauseKind>(Str)
108 #define OPENMP_LINEAR_KIND(Name) .Case(#Name, OMPC_LINEAR_##Name)
109 #include "clang/Basic/OpenMPKinds.def"
110         .Default(OMPC_LINEAR_unknown);
111   case OMPC_map:
112     return llvm::StringSwitch<unsigned>(Str)
113 #define OPENMP_MAP_KIND(Name)                                                  \
114   .Case(#Name, static_cast<unsigned>(OMPC_MAP_##Name))
115 #define OPENMP_MAP_MODIFIER_KIND(Name)                                         \
116   .Case(#Name, static_cast<unsigned>(OMPC_MAP_MODIFIER_##Name))
117 #include "clang/Basic/OpenMPKinds.def"
118         .Default(OMPC_MAP_unknown);
119   case OMPC_dist_schedule:
120     return llvm::StringSwitch<OpenMPDistScheduleClauseKind>(Str)
121 #define OPENMP_DIST_SCHEDULE_KIND(Name) .Case(#Name, OMPC_DIST_SCHEDULE_##Name)
122 #include "clang/Basic/OpenMPKinds.def"
123         .Default(OMPC_DIST_SCHEDULE_unknown);
124   case OMPC_defaultmap:
125     return llvm::StringSwitch<unsigned>(Str)
126 #define OPENMP_DEFAULTMAP_KIND(Name)                                           \
127   .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_##Name))
128 #define OPENMP_DEFAULTMAP_MODIFIER(Name)                                       \
129   .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_MODIFIER_##Name))
130 #include "clang/Basic/OpenMPKinds.def"
131         .Default(OMPC_DEFAULTMAP_unknown);
132   case OMPC_atomic_default_mem_order:
133      return llvm::StringSwitch<OpenMPAtomicDefaultMemOrderClauseKind>(Str)
134 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name)       \
135   .Case(#Name, OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name)
136 #include "clang/Basic/OpenMPKinds.def"
137         .Default(OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown);
138   case OMPC_unknown:
139   case OMPC_threadprivate:
140   case OMPC_if:
141   case OMPC_final:
142   case OMPC_num_threads:
143   case OMPC_safelen:
144   case OMPC_simdlen:
145   case OMPC_collapse:
146   case OMPC_private:
147   case OMPC_firstprivate:
148   case OMPC_lastprivate:
149   case OMPC_shared:
150   case OMPC_reduction:
151   case OMPC_task_reduction:
152   case OMPC_in_reduction:
153   case OMPC_aligned:
154   case OMPC_copyin:
155   case OMPC_copyprivate:
156   case OMPC_ordered:
157   case OMPC_nowait:
158   case OMPC_untied:
159   case OMPC_mergeable:
160   case OMPC_flush:
161   case OMPC_read:
162   case OMPC_write:
163   case OMPC_update:
164   case OMPC_capture:
165   case OMPC_seq_cst:
166   case OMPC_device:
167   case OMPC_threads:
168   case OMPC_simd:
169   case OMPC_num_teams:
170   case OMPC_thread_limit:
171   case OMPC_priority:
172   case OMPC_grainsize:
173   case OMPC_nogroup:
174   case OMPC_num_tasks:
175   case OMPC_hint:
176   case OMPC_uniform:
177   case OMPC_to:
178   case OMPC_from:
179   case OMPC_use_device_ptr:
180   case OMPC_is_device_ptr:
181   case OMPC_unified_address:
182   case OMPC_unified_shared_memory:
183   case OMPC_reverse_offload:
184   case OMPC_dynamic_allocators:
185     break;
186   }
187   llvm_unreachable("Invalid OpenMP simple clause kind");
188 }
189 
190 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
191                                                  unsigned Type) {
192   switch (Kind) {
193   case OMPC_default:
194     switch (Type) {
195     case OMPC_DEFAULT_unknown:
196       return "unknown";
197 #define OPENMP_DEFAULT_KIND(Name)                                              \
198   case OMPC_DEFAULT_##Name:                                                    \
199     return #Name;
200 #include "clang/Basic/OpenMPKinds.def"
201     }
202     llvm_unreachable("Invalid OpenMP 'default' clause type");
203   case OMPC_proc_bind:
204     switch (Type) {
205     case OMPC_PROC_BIND_unknown:
206       return "unknown";
207 #define OPENMP_PROC_BIND_KIND(Name)                                            \
208   case OMPC_PROC_BIND_##Name:                                                  \
209     return #Name;
210 #include "clang/Basic/OpenMPKinds.def"
211     }
212     llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
213   case OMPC_schedule:
214     switch (Type) {
215     case OMPC_SCHEDULE_unknown:
216     case OMPC_SCHEDULE_MODIFIER_last:
217       return "unknown";
218 #define OPENMP_SCHEDULE_KIND(Name)                                             \
219     case OMPC_SCHEDULE_##Name:                                                 \
220       return #Name;
221 #define OPENMP_SCHEDULE_MODIFIER(Name)                                         \
222     case OMPC_SCHEDULE_MODIFIER_##Name:                                        \
223       return #Name;
224 #include "clang/Basic/OpenMPKinds.def"
225     }
226     llvm_unreachable("Invalid OpenMP 'schedule' clause type");
227   case OMPC_depend:
228     switch (Type) {
229     case OMPC_DEPEND_unknown:
230       return "unknown";
231 #define OPENMP_DEPEND_KIND(Name)                                             \
232   case OMPC_DEPEND_##Name:                                                   \
233     return #Name;
234 #include "clang/Basic/OpenMPKinds.def"
235     }
236     llvm_unreachable("Invalid OpenMP 'depend' clause type");
237   case OMPC_linear:
238     switch (Type) {
239     case OMPC_LINEAR_unknown:
240       return "unknown";
241 #define OPENMP_LINEAR_KIND(Name)                                             \
242   case OMPC_LINEAR_##Name:                                                   \
243     return #Name;
244 #include "clang/Basic/OpenMPKinds.def"
245     }
246     llvm_unreachable("Invalid OpenMP 'linear' clause type");
247   case OMPC_map:
248     switch (Type) {
249     case OMPC_MAP_unknown:
250     case OMPC_MAP_MODIFIER_last:
251       return "unknown";
252 #define OPENMP_MAP_KIND(Name)                                                \
253   case OMPC_MAP_##Name:                                                      \
254     return #Name;
255 #define OPENMP_MAP_MODIFIER_KIND(Name)                                       \
256   case OMPC_MAP_MODIFIER_##Name:                                             \
257     return #Name;
258 #include "clang/Basic/OpenMPKinds.def"
259     default:
260       break;
261     }
262     llvm_unreachable("Invalid OpenMP 'map' clause type");
263   case OMPC_dist_schedule:
264     switch (Type) {
265     case OMPC_DIST_SCHEDULE_unknown:
266       return "unknown";
267 #define OPENMP_DIST_SCHEDULE_KIND(Name)                                      \
268   case OMPC_DIST_SCHEDULE_##Name:                                            \
269     return #Name;
270 #include "clang/Basic/OpenMPKinds.def"
271     }
272     llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type");
273   case OMPC_defaultmap:
274     switch (Type) {
275     case OMPC_DEFAULTMAP_unknown:
276     case OMPC_DEFAULTMAP_MODIFIER_last:
277       return "unknown";
278 #define OPENMP_DEFAULTMAP_KIND(Name)                                         \
279     case OMPC_DEFAULTMAP_##Name:                                             \
280       return #Name;
281 #define OPENMP_DEFAULTMAP_MODIFIER(Name)                                     \
282     case OMPC_DEFAULTMAP_MODIFIER_##Name:                                    \
283       return #Name;
284 #include "clang/Basic/OpenMPKinds.def"
285     }
286     llvm_unreachable("Invalid OpenMP 'schedule' clause type");
287   case OMPC_atomic_default_mem_order:
288     switch (Type) {
289     case OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown:
290       return "unknown";
291 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name)                           \
292     case OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name:                               \
293       return #Name;
294 #include "clang/Basic/OpenMPKinds.def"
295 }
296     llvm_unreachable("Invalid OpenMP 'atomic_default_mem_order' clause type");
297   case OMPC_unknown:
298   case OMPC_threadprivate:
299   case OMPC_if:
300   case OMPC_final:
301   case OMPC_num_threads:
302   case OMPC_safelen:
303   case OMPC_simdlen:
304   case OMPC_collapse:
305   case OMPC_private:
306   case OMPC_firstprivate:
307   case OMPC_lastprivate:
308   case OMPC_shared:
309   case OMPC_reduction:
310   case OMPC_task_reduction:
311   case OMPC_in_reduction:
312   case OMPC_aligned:
313   case OMPC_copyin:
314   case OMPC_copyprivate:
315   case OMPC_ordered:
316   case OMPC_nowait:
317   case OMPC_untied:
318   case OMPC_mergeable:
319   case OMPC_flush:
320   case OMPC_read:
321   case OMPC_write:
322   case OMPC_update:
323   case OMPC_capture:
324   case OMPC_seq_cst:
325   case OMPC_device:
326   case OMPC_threads:
327   case OMPC_simd:
328   case OMPC_num_teams:
329   case OMPC_thread_limit:
330   case OMPC_priority:
331   case OMPC_grainsize:
332   case OMPC_nogroup:
333   case OMPC_num_tasks:
334   case OMPC_hint:
335   case OMPC_uniform:
336   case OMPC_to:
337   case OMPC_from:
338   case OMPC_use_device_ptr:
339   case OMPC_is_device_ptr:
340   case OMPC_unified_address:
341   case OMPC_unified_shared_memory:
342   case OMPC_reverse_offload:
343   case OMPC_dynamic_allocators:
344     break;
345   }
346   llvm_unreachable("Invalid OpenMP simple clause kind");
347 }
348 
349 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
350                                         OpenMPClauseKind CKind) {
351   assert(DKind <= OMPD_unknown);
352   assert(CKind <= OMPC_unknown);
353   switch (DKind) {
354   case OMPD_parallel:
355     switch (CKind) {
356 #define OPENMP_PARALLEL_CLAUSE(Name)                                           \
357   case OMPC_##Name:                                                            \
358     return true;
359 #include "clang/Basic/OpenMPKinds.def"
360     default:
361       break;
362     }
363     break;
364   case OMPD_simd:
365     switch (CKind) {
366 #define OPENMP_SIMD_CLAUSE(Name)                                               \
367   case OMPC_##Name:                                                            \
368     return true;
369 #include "clang/Basic/OpenMPKinds.def"
370     default:
371       break;
372     }
373     break;
374   case OMPD_for:
375     switch (CKind) {
376 #define OPENMP_FOR_CLAUSE(Name)                                                \
377   case OMPC_##Name:                                                            \
378     return true;
379 #include "clang/Basic/OpenMPKinds.def"
380     default:
381       break;
382     }
383     break;
384   case OMPD_for_simd:
385     switch (CKind) {
386 #define OPENMP_FOR_SIMD_CLAUSE(Name)                                           \
387   case OMPC_##Name:                                                            \
388     return true;
389 #include "clang/Basic/OpenMPKinds.def"
390     default:
391       break;
392     }
393     break;
394   case OMPD_sections:
395     switch (CKind) {
396 #define OPENMP_SECTIONS_CLAUSE(Name)                                           \
397   case OMPC_##Name:                                                            \
398     return true;
399 #include "clang/Basic/OpenMPKinds.def"
400     default:
401       break;
402     }
403     break;
404   case OMPD_single:
405     switch (CKind) {
406 #define OPENMP_SINGLE_CLAUSE(Name)                                             \
407   case OMPC_##Name:                                                            \
408     return true;
409 #include "clang/Basic/OpenMPKinds.def"
410     default:
411       break;
412     }
413     break;
414   case OMPD_parallel_for:
415     switch (CKind) {
416 #define OPENMP_PARALLEL_FOR_CLAUSE(Name)                                       \
417   case OMPC_##Name:                                                            \
418     return true;
419 #include "clang/Basic/OpenMPKinds.def"
420     default:
421       break;
422     }
423     break;
424   case OMPD_parallel_for_simd:
425     switch (CKind) {
426 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name)                                  \
427   case OMPC_##Name:                                                            \
428     return true;
429 #include "clang/Basic/OpenMPKinds.def"
430     default:
431       break;
432     }
433     break;
434   case OMPD_parallel_sections:
435     switch (CKind) {
436 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name)                                  \
437   case OMPC_##Name:                                                            \
438     return true;
439 #include "clang/Basic/OpenMPKinds.def"
440     default:
441       break;
442     }
443     break;
444   case OMPD_task:
445     switch (CKind) {
446 #define OPENMP_TASK_CLAUSE(Name)                                               \
447   case OMPC_##Name:                                                            \
448     return true;
449 #include "clang/Basic/OpenMPKinds.def"
450     default:
451       break;
452     }
453     break;
454   case OMPD_flush:
455     return CKind == OMPC_flush;
456     break;
457   case OMPD_atomic:
458     switch (CKind) {
459 #define OPENMP_ATOMIC_CLAUSE(Name)                                             \
460   case OMPC_##Name:                                                            \
461     return true;
462 #include "clang/Basic/OpenMPKinds.def"
463     default:
464       break;
465     }
466     break;
467   case OMPD_target:
468     switch (CKind) {
469 #define OPENMP_TARGET_CLAUSE(Name)                                             \
470   case OMPC_##Name:                                                            \
471     return true;
472 #include "clang/Basic/OpenMPKinds.def"
473     default:
474       break;
475     }
476     break;
477   case OMPD_requires:
478     switch (CKind) {
479 #define OPENMP_REQUIRES_CLAUSE(Name)                                             \
480   case OMPC_##Name:                                                            \
481     return true;
482 #include "clang/Basic/OpenMPKinds.def"
483     default:
484       break;
485     }
486     break;
487   case OMPD_target_data:
488     switch (CKind) {
489 #define OPENMP_TARGET_DATA_CLAUSE(Name)                                        \
490   case OMPC_##Name:                                                            \
491     return true;
492 #include "clang/Basic/OpenMPKinds.def"
493     default:
494       break;
495     }
496     break;
497   case OMPD_target_enter_data:
498     switch (CKind) {
499 #define OPENMP_TARGET_ENTER_DATA_CLAUSE(Name)                                  \
500   case OMPC_##Name:                                                            \
501     return true;
502 #include "clang/Basic/OpenMPKinds.def"
503     default:
504       break;
505     }
506     break;
507   case OMPD_target_exit_data:
508     switch (CKind) {
509 #define OPENMP_TARGET_EXIT_DATA_CLAUSE(Name)                                   \
510   case OMPC_##Name:                                                            \
511     return true;
512 #include "clang/Basic/OpenMPKinds.def"
513     default:
514       break;
515     }
516     break;
517   case OMPD_target_parallel:
518     switch (CKind) {
519 #define OPENMP_TARGET_PARALLEL_CLAUSE(Name)                                    \
520   case OMPC_##Name:                                                            \
521     return true;
522 #include "clang/Basic/OpenMPKinds.def"
523     default:
524       break;
525     }
526     break;
527   case OMPD_target_parallel_for:
528     switch (CKind) {
529 #define OPENMP_TARGET_PARALLEL_FOR_CLAUSE(Name)                                \
530   case OMPC_##Name:                                                            \
531     return true;
532 #include "clang/Basic/OpenMPKinds.def"
533     default:
534       break;
535     }
536     break;
537   case OMPD_target_update:
538     switch (CKind) {
539 #define OPENMP_TARGET_UPDATE_CLAUSE(Name)                                      \
540   case OMPC_##Name:                                                            \
541     return true;
542 #include "clang/Basic/OpenMPKinds.def"
543     default:
544       break;
545     }
546     break;
547   case OMPD_teams:
548     switch (CKind) {
549 #define OPENMP_TEAMS_CLAUSE(Name)                                              \
550   case OMPC_##Name:                                                            \
551     return true;
552 #include "clang/Basic/OpenMPKinds.def"
553     default:
554       break;
555     }
556     break;
557   case OMPD_declare_simd:
558     break;
559   case OMPD_cancel:
560     switch (CKind) {
561 #define OPENMP_CANCEL_CLAUSE(Name)                                             \
562   case OMPC_##Name:                                                            \
563     return true;
564 #include "clang/Basic/OpenMPKinds.def"
565     default:
566       break;
567     }
568     break;
569   case OMPD_ordered:
570     switch (CKind) {
571 #define OPENMP_ORDERED_CLAUSE(Name)                                            \
572   case OMPC_##Name:                                                            \
573     return true;
574 #include "clang/Basic/OpenMPKinds.def"
575     default:
576       break;
577     }
578     break;
579   case OMPD_taskloop:
580     switch (CKind) {
581 #define OPENMP_TASKLOOP_CLAUSE(Name)                                           \
582   case OMPC_##Name:                                                            \
583     return true;
584 #include "clang/Basic/OpenMPKinds.def"
585     default:
586       break;
587     }
588     break;
589   case OMPD_taskloop_simd:
590     switch (CKind) {
591 #define OPENMP_TASKLOOP_SIMD_CLAUSE(Name)                                      \
592   case OMPC_##Name:                                                            \
593     return true;
594 #include "clang/Basic/OpenMPKinds.def"
595     default:
596       break;
597     }
598     break;
599   case OMPD_critical:
600     switch (CKind) {
601 #define OPENMP_CRITICAL_CLAUSE(Name)                                           \
602   case OMPC_##Name:                                                            \
603     return true;
604 #include "clang/Basic/OpenMPKinds.def"
605     default:
606       break;
607     }
608     break;
609   case OMPD_distribute:
610     switch (CKind) {
611 #define OPENMP_DISTRIBUTE_CLAUSE(Name)                                         \
612   case OMPC_##Name:                                                            \
613     return true;
614 #include "clang/Basic/OpenMPKinds.def"
615     default:
616       break;
617     }
618     break;
619   case OMPD_distribute_parallel_for:
620     switch (CKind) {
621 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name)                            \
622   case OMPC_##Name:                                                            \
623     return true;
624 #include "clang/Basic/OpenMPKinds.def"
625     default:
626       break;
627     }
628     break;
629   case OMPD_distribute_parallel_for_simd:
630     switch (CKind) {
631 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name)                       \
632   case OMPC_##Name:                                                            \
633     return true;
634 #include "clang/Basic/OpenMPKinds.def"
635     default:
636       break;
637     }
638     break;
639   case OMPD_distribute_simd:
640     switch (CKind) {
641 #define OPENMP_DISTRIBUTE_SIMD_CLAUSE(Name)                                    \
642   case OMPC_##Name:                                                            \
643     return true;
644 #include "clang/Basic/OpenMPKinds.def"
645     default:
646       break;
647     }
648     break;
649   case OMPD_target_parallel_for_simd:
650     switch (CKind) {
651 #define OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(Name)                           \
652   case OMPC_##Name:                                                            \
653     return true;
654 #include "clang/Basic/OpenMPKinds.def"
655     default:
656       break;
657     }
658     break;
659   case OMPD_target_simd:
660     switch (CKind) {
661 #define OPENMP_TARGET_SIMD_CLAUSE(Name)                                        \
662   case OMPC_##Name:                                                            \
663     return true;
664 #include "clang/Basic/OpenMPKinds.def"
665     default:
666       break;
667     }
668     break;
669   case OMPD_teams_distribute:
670     switch (CKind) {
671 #define OPENMP_TEAMS_DISTRIBUTE_CLAUSE(Name)                                   \
672   case OMPC_##Name:                                                            \
673     return true;
674 #include "clang/Basic/OpenMPKinds.def"
675     default:
676       break;
677     }
678     break;
679   case OMPD_teams_distribute_simd:
680     switch (CKind) {
681 #define OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name)                              \
682   case OMPC_##Name:                                                            \
683     return true;
684 #include "clang/Basic/OpenMPKinds.def"
685     default:
686       break;
687     }
688     break;
689   case OMPD_teams_distribute_parallel_for_simd:
690     switch (CKind) {
691 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name)                 \
692   case OMPC_##Name:                                                            \
693     return true;
694 #include "clang/Basic/OpenMPKinds.def"
695     default:
696       break;
697     }
698     break;
699   case OMPD_teams_distribute_parallel_for:
700     switch (CKind) {
701 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name)                      \
702   case OMPC_##Name:                                                            \
703     return true;
704 #include "clang/Basic/OpenMPKinds.def"
705     default:
706       break;
707     }
708     break;
709   case OMPD_target_teams:
710     switch (CKind) {
711 #define OPENMP_TARGET_TEAMS_CLAUSE(Name)                                       \
712   case OMPC_##Name:                                                            \
713     return true;
714 #include "clang/Basic/OpenMPKinds.def"
715     default:
716       break;
717     }
718     break;
719   case OMPD_target_teams_distribute:
720     switch (CKind) {
721 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(Name)                            \
722   case OMPC_##Name:                                                            \
723     return true;
724 #include "clang/Basic/OpenMPKinds.def"
725     default:
726       break;
727     }
728     break;
729   case OMPD_target_teams_distribute_parallel_for:
730     switch (CKind) {
731 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name)               \
732   case OMPC_##Name:                                                            \
733     return true;
734 #include "clang/Basic/OpenMPKinds.def"
735     default:
736       break;
737     }
738     break;
739   case OMPD_target_teams_distribute_parallel_for_simd:
740     switch (CKind) {
741 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name)          \
742   case OMPC_##Name:                                                            \
743     return true;
744 #include "clang/Basic/OpenMPKinds.def"
745     default:
746       break;
747     }
748     break;
749   case OMPD_target_teams_distribute_simd:
750     switch (CKind) {
751 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name)                       \
752   case OMPC_##Name:                                                            \
753     return true;
754 #include "clang/Basic/OpenMPKinds.def"
755     default:
756       break;
757     }
758     break;
759   case OMPD_taskgroup:
760     switch (CKind) {
761 #define OPENMP_TASKGROUP_CLAUSE(Name)                                          \
762   case OMPC_##Name:                                                            \
763     return true;
764 #include "clang/Basic/OpenMPKinds.def"
765     default:
766       break;
767     }
768     break;
769   case OMPD_declare_mapper:
770     switch (CKind) {
771 #define OPENMP_DECLARE_MAPPER_CLAUSE(Name)                                     \
772   case OMPC_##Name:                                                            \
773     return true;
774 #include "clang/Basic/OpenMPKinds.def"
775     default:
776       break;
777     }
778     break;
779   case OMPD_declare_target:
780   case OMPD_end_declare_target:
781   case OMPD_unknown:
782   case OMPD_threadprivate:
783   case OMPD_section:
784   case OMPD_master:
785   case OMPD_taskyield:
786   case OMPD_barrier:
787   case OMPD_taskwait:
788   case OMPD_cancellation_point:
789   case OMPD_declare_reduction:
790     break;
791   }
792   return false;
793 }
794 
795 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
796   return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
797          DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
798          DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
799          DKind == OMPD_distribute || DKind == OMPD_target_parallel_for ||
800          DKind == OMPD_distribute_parallel_for ||
801          DKind == OMPD_distribute_parallel_for_simd ||
802          DKind == OMPD_distribute_simd ||
803          DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
804          DKind == OMPD_teams_distribute ||
805          DKind == OMPD_teams_distribute_simd ||
806          DKind == OMPD_teams_distribute_parallel_for_simd ||
807          DKind == OMPD_teams_distribute_parallel_for ||
808          DKind == OMPD_target_teams_distribute ||
809          DKind == OMPD_target_teams_distribute_parallel_for ||
810          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
811          DKind == OMPD_target_teams_distribute_simd;
812 }
813 
814 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
815   return DKind == OMPD_for || DKind == OMPD_for_simd ||
816          DKind == OMPD_sections || DKind == OMPD_section ||
817          DKind == OMPD_single || DKind == OMPD_parallel_for ||
818          DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
819          DKind == OMPD_target_parallel_for ||
820          DKind == OMPD_distribute_parallel_for ||
821          DKind == OMPD_distribute_parallel_for_simd ||
822          DKind == OMPD_target_parallel_for_simd ||
823          DKind == OMPD_teams_distribute_parallel_for_simd ||
824          DKind == OMPD_teams_distribute_parallel_for ||
825          DKind == OMPD_target_teams_distribute_parallel_for ||
826          DKind == OMPD_target_teams_distribute_parallel_for_simd;
827 }
828 
829 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) {
830   return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd;
831 }
832 
833 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
834   return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
835          DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
836          DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for ||
837          DKind == OMPD_distribute_parallel_for ||
838          DKind == OMPD_distribute_parallel_for_simd ||
839          DKind == OMPD_target_parallel_for_simd ||
840          DKind == OMPD_teams_distribute_parallel_for ||
841          DKind == OMPD_teams_distribute_parallel_for_simd ||
842          DKind == OMPD_target_teams_distribute_parallel_for ||
843          DKind == OMPD_target_teams_distribute_parallel_for_simd;
844 }
845 
846 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) {
847   return DKind == OMPD_target || DKind == OMPD_target_parallel ||
848          DKind == OMPD_target_parallel_for ||
849          DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
850          DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
851          DKind == OMPD_target_teams_distribute_parallel_for ||
852          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
853          DKind == OMPD_target_teams_distribute_simd;
854 }
855 
856 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) {
857   return DKind == OMPD_target_data || DKind == OMPD_target_enter_data ||
858          DKind == OMPD_target_exit_data || DKind == OMPD_target_update;
859 }
860 
861 bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) {
862   return DKind == OMPD_teams || DKind == OMPD_teams_distribute ||
863          DKind == OMPD_teams_distribute_simd ||
864          DKind == OMPD_teams_distribute_parallel_for_simd ||
865          DKind == OMPD_teams_distribute_parallel_for;
866 }
867 
868 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) {
869   return isOpenMPNestingTeamsDirective(DKind) ||
870          DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
871          DKind == OMPD_target_teams_distribute_parallel_for ||
872          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
873          DKind == OMPD_target_teams_distribute_simd;
874 }
875 
876 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
877   return DKind == OMPD_simd || DKind == OMPD_for_simd ||
878          DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd ||
879          DKind == OMPD_distribute_parallel_for_simd ||
880          DKind == OMPD_distribute_simd || DKind == OMPD_target_simd ||
881          DKind == OMPD_teams_distribute_simd ||
882          DKind == OMPD_teams_distribute_parallel_for_simd ||
883          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
884          DKind == OMPD_target_teams_distribute_simd ||
885          DKind == OMPD_target_parallel_for_simd;
886 }
887 
888 bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) {
889   return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for ||
890          Kind == OMPD_distribute_parallel_for_simd ||
891          Kind == OMPD_distribute_simd;
892   // TODO add next directives.
893 }
894 
895 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) {
896   return isOpenMPNestingDistributeDirective(Kind) ||
897          Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd ||
898          Kind == OMPD_teams_distribute_parallel_for_simd ||
899          Kind == OMPD_teams_distribute_parallel_for ||
900          Kind == OMPD_target_teams_distribute ||
901          Kind == OMPD_target_teams_distribute_parallel_for ||
902          Kind == OMPD_target_teams_distribute_parallel_for_simd ||
903          Kind == OMPD_target_teams_distribute_simd;
904 }
905 
906 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
907   return Kind == OMPC_private || Kind == OMPC_firstprivate ||
908          Kind == OMPC_lastprivate || Kind == OMPC_linear ||
909          Kind == OMPC_reduction || Kind == OMPC_task_reduction ||
910          Kind == OMPC_in_reduction; // TODO add next clauses like 'reduction'.
911 }
912 
913 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
914   return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
915 }
916 
917 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) {
918   return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind);
919 }
920 
921 bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) {
922   return Kind == OMPD_distribute_parallel_for ||
923          Kind == OMPD_distribute_parallel_for_simd ||
924          Kind == OMPD_teams_distribute_parallel_for_simd ||
925          Kind == OMPD_teams_distribute_parallel_for ||
926          Kind == OMPD_target_teams_distribute_parallel_for ||
927          Kind == OMPD_target_teams_distribute_parallel_for_simd;
928 }
929 
930 void clang::getOpenMPCaptureRegions(
931     SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions,
932     OpenMPDirectiveKind DKind) {
933   assert(DKind <= OMPD_unknown);
934   switch (DKind) {
935   case OMPD_parallel:
936   case OMPD_parallel_for:
937   case OMPD_parallel_for_simd:
938   case OMPD_parallel_sections:
939   case OMPD_distribute_parallel_for:
940   case OMPD_distribute_parallel_for_simd:
941     CaptureRegions.push_back(OMPD_parallel);
942     break;
943   case OMPD_target_teams:
944   case OMPD_target_teams_distribute:
945   case OMPD_target_teams_distribute_simd:
946     CaptureRegions.push_back(OMPD_task);
947     CaptureRegions.push_back(OMPD_target);
948     CaptureRegions.push_back(OMPD_teams);
949     break;
950   case OMPD_teams:
951   case OMPD_teams_distribute:
952   case OMPD_teams_distribute_simd:
953     CaptureRegions.push_back(OMPD_teams);
954     break;
955   case OMPD_target:
956   case OMPD_target_simd:
957     CaptureRegions.push_back(OMPD_task);
958     CaptureRegions.push_back(OMPD_target);
959     break;
960   case OMPD_teams_distribute_parallel_for:
961   case OMPD_teams_distribute_parallel_for_simd:
962     CaptureRegions.push_back(OMPD_teams);
963     CaptureRegions.push_back(OMPD_parallel);
964     break;
965   case OMPD_target_parallel:
966   case OMPD_target_parallel_for:
967   case OMPD_target_parallel_for_simd:
968     CaptureRegions.push_back(OMPD_task);
969     CaptureRegions.push_back(OMPD_target);
970     CaptureRegions.push_back(OMPD_parallel);
971     break;
972   case OMPD_task:
973   case OMPD_target_enter_data:
974   case OMPD_target_exit_data:
975   case OMPD_target_update:
976     CaptureRegions.push_back(OMPD_task);
977     break;
978   case OMPD_taskloop:
979   case OMPD_taskloop_simd:
980     CaptureRegions.push_back(OMPD_taskloop);
981     break;
982   case OMPD_target_teams_distribute_parallel_for:
983   case OMPD_target_teams_distribute_parallel_for_simd:
984     CaptureRegions.push_back(OMPD_task);
985     CaptureRegions.push_back(OMPD_target);
986     CaptureRegions.push_back(OMPD_teams);
987     CaptureRegions.push_back(OMPD_parallel);
988     break;
989   case OMPD_simd:
990   case OMPD_for:
991   case OMPD_for_simd:
992   case OMPD_sections:
993   case OMPD_section:
994   case OMPD_single:
995   case OMPD_master:
996   case OMPD_critical:
997   case OMPD_taskgroup:
998   case OMPD_distribute:
999   case OMPD_ordered:
1000   case OMPD_atomic:
1001   case OMPD_target_data:
1002   case OMPD_distribute_simd:
1003     CaptureRegions.push_back(OMPD_unknown);
1004     break;
1005   case OMPD_threadprivate:
1006   case OMPD_taskyield:
1007   case OMPD_barrier:
1008   case OMPD_taskwait:
1009   case OMPD_cancellation_point:
1010   case OMPD_cancel:
1011   case OMPD_flush:
1012   case OMPD_declare_reduction:
1013   case OMPD_declare_mapper:
1014   case OMPD_declare_simd:
1015   case OMPD_declare_target:
1016   case OMPD_end_declare_target:
1017   case OMPD_requires:
1018     llvm_unreachable("OpenMP Directive is not allowed");
1019   case OMPD_unknown:
1020     llvm_unreachable("Unknown OpenMP directive");
1021   }
1022 }
1023