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