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     switch (CKind) {
812 #define OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name)                              \
813   case OMPC_##Name:                                                            \
814     return true;
815 #include "clang/Basic/OpenMPKinds.def"
816     default:
817       break;
818     }
819     break;
820   case OMPD_teams_distribute_parallel_for_simd:
821     switch (CKind) {
822 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name)                 \
823   case OMPC_##Name:                                                            \
824     return true;
825 #include "clang/Basic/OpenMPKinds.def"
826     default:
827       break;
828     }
829     break;
830   case OMPD_teams_distribute_parallel_for:
831     switch (CKind) {
832 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name)                      \
833   case OMPC_##Name:                                                            \
834     return true;
835 #include "clang/Basic/OpenMPKinds.def"
836     default:
837       break;
838     }
839     break;
840   case OMPD_target_teams:
841     switch (CKind) {
842 #define OPENMP_TARGET_TEAMS_CLAUSE(Name)                                       \
843   case OMPC_##Name:                                                            \
844     return true;
845 #include "clang/Basic/OpenMPKinds.def"
846     default:
847       break;
848     }
849     break;
850   case OMPD_target_teams_distribute:
851     switch (CKind) {
852 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(Name)                            \
853   case OMPC_##Name:                                                            \
854     return true;
855 #include "clang/Basic/OpenMPKinds.def"
856     default:
857       break;
858     }
859     break;
860   case OMPD_target_teams_distribute_parallel_for:
861     switch (CKind) {
862 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name)               \
863   case OMPC_##Name:                                                            \
864     return true;
865 #include "clang/Basic/OpenMPKinds.def"
866     default:
867       break;
868     }
869     break;
870   case OMPD_target_teams_distribute_parallel_for_simd:
871     switch (CKind) {
872 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name)          \
873   case OMPC_##Name:                                                            \
874     return true;
875 #include "clang/Basic/OpenMPKinds.def"
876     default:
877       break;
878     }
879     break;
880   case OMPD_target_teams_distribute_simd:
881     switch (CKind) {
882 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name)                       \
883   case OMPC_##Name:                                                            \
884     return true;
885 #include "clang/Basic/OpenMPKinds.def"
886     default:
887       break;
888     }
889     break;
890   case OMPD_taskgroup:
891     switch (CKind) {
892 #define OPENMP_TASKGROUP_CLAUSE(Name)                                          \
893   case OMPC_##Name:                                                            \
894     return true;
895 #include "clang/Basic/OpenMPKinds.def"
896     default:
897       break;
898     }
899     break;
900   case OMPD_declare_mapper:
901     switch (CKind) {
902 #define OPENMP_DECLARE_MAPPER_CLAUSE(Name)                                     \
903   case OMPC_##Name:                                                            \
904     return true;
905 #include "clang/Basic/OpenMPKinds.def"
906     default:
907       break;
908     }
909     break;
910   case OMPD_allocate:
911     switch (CKind) {
912 #define OPENMP_ALLOCATE_CLAUSE(Name)                                           \
913   case OMPC_##Name:                                                            \
914     return true;
915 #include "clang/Basic/OpenMPKinds.def"
916     default:
917       break;
918     }
919     break;
920   case OMPD_declare_variant:
921     switch (CKind) {
922 #define OPENMP_DECLARE_VARIANT_CLAUSE(Name)                                    \
923   case OMPC_##Name:                                                            \
924     return true;
925 #include "clang/Basic/OpenMPKinds.def"
926     default:
927       break;
928     }
929     break;
930   case OMPD_declare_target:
931   case OMPD_end_declare_target:
932   case OMPD_unknown:
933   case OMPD_threadprivate:
934   case OMPD_section:
935   case OMPD_master:
936   case OMPD_taskyield:
937   case OMPD_barrier:
938   case OMPD_taskwait:
939   case OMPD_cancellation_point:
940   case OMPD_declare_reduction:
941   case OMPD_declare_simd:
942     break;
943   }
944   return false;
945 }
946 
947 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
948   return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
949          DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
950          DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
951          DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd ||
952          DKind == OMPD_parallel_master_taskloop ||
953          DKind == OMPD_parallel_master_taskloop_simd ||
954          DKind == OMPD_distribute || DKind == OMPD_target_parallel_for ||
955          DKind == OMPD_distribute_parallel_for ||
956          DKind == OMPD_distribute_parallel_for_simd ||
957          DKind == OMPD_distribute_simd ||
958          DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
959          DKind == OMPD_teams_distribute ||
960          DKind == OMPD_teams_distribute_simd ||
961          DKind == OMPD_teams_distribute_parallel_for_simd ||
962          DKind == OMPD_teams_distribute_parallel_for ||
963          DKind == OMPD_target_teams_distribute ||
964          DKind == OMPD_target_teams_distribute_parallel_for ||
965          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
966          DKind == OMPD_target_teams_distribute_simd;
967 }
968 
969 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
970   return DKind == OMPD_for || DKind == OMPD_for_simd ||
971          DKind == OMPD_sections || DKind == OMPD_section ||
972          DKind == OMPD_single || DKind == OMPD_parallel_for ||
973          DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
974          DKind == OMPD_target_parallel_for ||
975          DKind == OMPD_distribute_parallel_for ||
976          DKind == OMPD_distribute_parallel_for_simd ||
977          DKind == OMPD_target_parallel_for_simd ||
978          DKind == OMPD_teams_distribute_parallel_for_simd ||
979          DKind == OMPD_teams_distribute_parallel_for ||
980          DKind == OMPD_target_teams_distribute_parallel_for ||
981          DKind == OMPD_target_teams_distribute_parallel_for_simd;
982 }
983 
984 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) {
985   return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
986          DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd ||
987          DKind == OMPD_parallel_master_taskloop ||
988          DKind == OMPD_parallel_master_taskloop_simd;
989 }
990 
991 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
992   return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
993          DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
994          DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for ||
995          DKind == OMPD_distribute_parallel_for ||
996          DKind == OMPD_distribute_parallel_for_simd ||
997          DKind == OMPD_target_parallel_for_simd ||
998          DKind == OMPD_teams_distribute_parallel_for ||
999          DKind == OMPD_teams_distribute_parallel_for_simd ||
1000          DKind == OMPD_target_teams_distribute_parallel_for ||
1001          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
1002          DKind == OMPD_parallel_master ||
1003          DKind == OMPD_parallel_master_taskloop ||
1004          DKind == OMPD_parallel_master_taskloop_simd;
1005 }
1006 
1007 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) {
1008   return DKind == OMPD_target || DKind == OMPD_target_parallel ||
1009          DKind == OMPD_target_parallel_for ||
1010          DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
1011          DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
1012          DKind == OMPD_target_teams_distribute_parallel_for ||
1013          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
1014          DKind == OMPD_target_teams_distribute_simd;
1015 }
1016 
1017 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) {
1018   return DKind == OMPD_target_data || DKind == OMPD_target_enter_data ||
1019          DKind == OMPD_target_exit_data || DKind == OMPD_target_update;
1020 }
1021 
1022 bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) {
1023   return DKind == OMPD_teams || DKind == OMPD_teams_distribute ||
1024          DKind == OMPD_teams_distribute_simd ||
1025          DKind == OMPD_teams_distribute_parallel_for_simd ||
1026          DKind == OMPD_teams_distribute_parallel_for;
1027 }
1028 
1029 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) {
1030   return isOpenMPNestingTeamsDirective(DKind) ||
1031          DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
1032          DKind == OMPD_target_teams_distribute_parallel_for ||
1033          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
1034          DKind == OMPD_target_teams_distribute_simd;
1035 }
1036 
1037 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
1038   return DKind == OMPD_simd || DKind == OMPD_for_simd ||
1039          DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd ||
1040          DKind == OMPD_master_taskloop_simd ||
1041          DKind == OMPD_parallel_master_taskloop_simd ||
1042          DKind == OMPD_distribute_parallel_for_simd ||
1043          DKind == OMPD_distribute_simd || DKind == OMPD_target_simd ||
1044          DKind == OMPD_teams_distribute_simd ||
1045          DKind == OMPD_teams_distribute_parallel_for_simd ||
1046          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
1047          DKind == OMPD_target_teams_distribute_simd ||
1048          DKind == OMPD_target_parallel_for_simd;
1049 }
1050 
1051 bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) {
1052   return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for ||
1053          Kind == OMPD_distribute_parallel_for_simd ||
1054          Kind == OMPD_distribute_simd;
1055   // TODO add next directives.
1056 }
1057 
1058 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) {
1059   return isOpenMPNestingDistributeDirective(Kind) ||
1060          Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd ||
1061          Kind == OMPD_teams_distribute_parallel_for_simd ||
1062          Kind == OMPD_teams_distribute_parallel_for ||
1063          Kind == OMPD_target_teams_distribute ||
1064          Kind == OMPD_target_teams_distribute_parallel_for ||
1065          Kind == OMPD_target_teams_distribute_parallel_for_simd ||
1066          Kind == OMPD_target_teams_distribute_simd;
1067 }
1068 
1069 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
1070   return Kind == OMPC_private || Kind == OMPC_firstprivate ||
1071          Kind == OMPC_lastprivate || Kind == OMPC_linear ||
1072          Kind == OMPC_reduction || Kind == OMPC_task_reduction ||
1073          Kind == OMPC_in_reduction; // TODO add next clauses like 'reduction'.
1074 }
1075 
1076 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
1077   return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
1078 }
1079 
1080 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) {
1081   return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind);
1082 }
1083 
1084 bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) {
1085   return Kind == OMPD_distribute_parallel_for ||
1086          Kind == OMPD_distribute_parallel_for_simd ||
1087          Kind == OMPD_teams_distribute_parallel_for_simd ||
1088          Kind == OMPD_teams_distribute_parallel_for ||
1089          Kind == OMPD_target_teams_distribute_parallel_for ||
1090          Kind == OMPD_target_teams_distribute_parallel_for_simd;
1091 }
1092 
1093 void clang::getOpenMPCaptureRegions(
1094     SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions,
1095     OpenMPDirectiveKind DKind) {
1096   assert(DKind <= OMPD_unknown);
1097   switch (DKind) {
1098   case OMPD_parallel:
1099   case OMPD_parallel_for:
1100   case OMPD_parallel_for_simd:
1101   case OMPD_parallel_master:
1102   case OMPD_parallel_sections:
1103   case OMPD_distribute_parallel_for:
1104   case OMPD_distribute_parallel_for_simd:
1105     CaptureRegions.push_back(OMPD_parallel);
1106     break;
1107   case OMPD_target_teams:
1108   case OMPD_target_teams_distribute:
1109   case OMPD_target_teams_distribute_simd:
1110     CaptureRegions.push_back(OMPD_task);
1111     CaptureRegions.push_back(OMPD_target);
1112     CaptureRegions.push_back(OMPD_teams);
1113     break;
1114   case OMPD_teams:
1115   case OMPD_teams_distribute:
1116   case OMPD_teams_distribute_simd:
1117     CaptureRegions.push_back(OMPD_teams);
1118     break;
1119   case OMPD_target:
1120   case OMPD_target_simd:
1121     CaptureRegions.push_back(OMPD_task);
1122     CaptureRegions.push_back(OMPD_target);
1123     break;
1124   case OMPD_teams_distribute_parallel_for:
1125   case OMPD_teams_distribute_parallel_for_simd:
1126     CaptureRegions.push_back(OMPD_teams);
1127     CaptureRegions.push_back(OMPD_parallel);
1128     break;
1129   case OMPD_target_parallel:
1130   case OMPD_target_parallel_for:
1131   case OMPD_target_parallel_for_simd:
1132     CaptureRegions.push_back(OMPD_task);
1133     CaptureRegions.push_back(OMPD_target);
1134     CaptureRegions.push_back(OMPD_parallel);
1135     break;
1136   case OMPD_task:
1137   case OMPD_target_enter_data:
1138   case OMPD_target_exit_data:
1139   case OMPD_target_update:
1140     CaptureRegions.push_back(OMPD_task);
1141     break;
1142   case OMPD_taskloop:
1143   case OMPD_taskloop_simd:
1144   case OMPD_master_taskloop:
1145   case OMPD_master_taskloop_simd:
1146     CaptureRegions.push_back(OMPD_taskloop);
1147     break;
1148   case OMPD_parallel_master_taskloop:
1149   case OMPD_parallel_master_taskloop_simd:
1150     CaptureRegions.push_back(OMPD_parallel);
1151     CaptureRegions.push_back(OMPD_taskloop);
1152     break;
1153   case OMPD_target_teams_distribute_parallel_for:
1154   case OMPD_target_teams_distribute_parallel_for_simd:
1155     CaptureRegions.push_back(OMPD_task);
1156     CaptureRegions.push_back(OMPD_target);
1157     CaptureRegions.push_back(OMPD_teams);
1158     CaptureRegions.push_back(OMPD_parallel);
1159     break;
1160   case OMPD_simd:
1161   case OMPD_for:
1162   case OMPD_for_simd:
1163   case OMPD_sections:
1164   case OMPD_section:
1165   case OMPD_single:
1166   case OMPD_master:
1167   case OMPD_critical:
1168   case OMPD_taskgroup:
1169   case OMPD_distribute:
1170   case OMPD_ordered:
1171   case OMPD_atomic:
1172   case OMPD_target_data:
1173   case OMPD_distribute_simd:
1174     CaptureRegions.push_back(OMPD_unknown);
1175     break;
1176   case OMPD_threadprivate:
1177   case OMPD_allocate:
1178   case OMPD_taskyield:
1179   case OMPD_barrier:
1180   case OMPD_taskwait:
1181   case OMPD_cancellation_point:
1182   case OMPD_cancel:
1183   case OMPD_flush:
1184   case OMPD_declare_reduction:
1185   case OMPD_declare_mapper:
1186   case OMPD_declare_simd:
1187   case OMPD_declare_target:
1188   case OMPD_end_declare_target:
1189   case OMPD_requires:
1190   case OMPD_declare_variant:
1191     llvm_unreachable("OpenMP Directive is not allowed");
1192   case OMPD_unknown:
1193     llvm_unreachable("Unknown OpenMP directive");
1194   }
1195 }
1196