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