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