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     switch (CKind) {
489 #define OPENMP_FOR_SIMD_CLAUSE(Name)                                           \
490   case OMPC_##Name:                                                            \
491     return true;
492 #include "clang/Basic/OpenMPKinds.def"
493     default:
494       break;
495     }
496     break;
497   case OMPD_sections:
498     switch (CKind) {
499 #define OPENMP_SECTIONS_CLAUSE(Name)                                           \
500   case OMPC_##Name:                                                            \
501     return true;
502 #include "clang/Basic/OpenMPKinds.def"
503     default:
504       break;
505     }
506     break;
507   case OMPD_single:
508     switch (CKind) {
509 #define OPENMP_SINGLE_CLAUSE(Name)                                             \
510   case OMPC_##Name:                                                            \
511     return true;
512 #include "clang/Basic/OpenMPKinds.def"
513     default:
514       break;
515     }
516     break;
517   case OMPD_parallel_for:
518     switch (CKind) {
519 #define OPENMP_PARALLEL_FOR_CLAUSE(Name)                                       \
520   case OMPC_##Name:                                                            \
521     return true;
522 #include "clang/Basic/OpenMPKinds.def"
523     default:
524       break;
525     }
526     break;
527   case OMPD_parallel_for_simd:
528     switch (CKind) {
529 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name)                                  \
530   case OMPC_##Name:                                                            \
531     return true;
532 #include "clang/Basic/OpenMPKinds.def"
533     default:
534       break;
535     }
536     break;
537   case OMPD_parallel_sections:
538     switch (CKind) {
539 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name)                                  \
540   case OMPC_##Name:                                                            \
541     return true;
542 #include "clang/Basic/OpenMPKinds.def"
543     default:
544       break;
545     }
546     break;
547   case OMPD_task:
548     switch (CKind) {
549 #define OPENMP_TASK_CLAUSE(Name)                                               \
550   case OMPC_##Name:                                                            \
551     return true;
552 #include "clang/Basic/OpenMPKinds.def"
553     default:
554       break;
555     }
556     break;
557   case OMPD_flush:
558     return CKind == OMPC_flush;
559     break;
560   case OMPD_atomic:
561     switch (CKind) {
562 #define OPENMP_ATOMIC_CLAUSE(Name)                                             \
563   case OMPC_##Name:                                                            \
564     return true;
565 #include "clang/Basic/OpenMPKinds.def"
566     default:
567       break;
568     }
569     break;
570   case OMPD_target:
571     switch (CKind) {
572 #define OPENMP_TARGET_CLAUSE(Name)                                             \
573   case OMPC_##Name:                                                            \
574     return true;
575 #include "clang/Basic/OpenMPKinds.def"
576     default:
577       break;
578     }
579     break;
580   case OMPD_requires:
581     switch (CKind) {
582 #define OPENMP_REQUIRES_CLAUSE(Name)                                             \
583   case OMPC_##Name:                                                            \
584     return true;
585 #include "clang/Basic/OpenMPKinds.def"
586     default:
587       break;
588     }
589     break;
590   case OMPD_target_data:
591     switch (CKind) {
592 #define OPENMP_TARGET_DATA_CLAUSE(Name)                                        \
593   case OMPC_##Name:                                                            \
594     return true;
595 #include "clang/Basic/OpenMPKinds.def"
596     default:
597       break;
598     }
599     break;
600   case OMPD_target_enter_data:
601     switch (CKind) {
602 #define OPENMP_TARGET_ENTER_DATA_CLAUSE(Name)                                  \
603   case OMPC_##Name:                                                            \
604     return true;
605 #include "clang/Basic/OpenMPKinds.def"
606     default:
607       break;
608     }
609     break;
610   case OMPD_target_exit_data:
611     switch (CKind) {
612 #define OPENMP_TARGET_EXIT_DATA_CLAUSE(Name)                                   \
613   case OMPC_##Name:                                                            \
614     return true;
615 #include "clang/Basic/OpenMPKinds.def"
616     default:
617       break;
618     }
619     break;
620   case OMPD_target_parallel:
621     switch (CKind) {
622 #define OPENMP_TARGET_PARALLEL_CLAUSE(Name)                                    \
623   case OMPC_##Name:                                                            \
624     return true;
625 #include "clang/Basic/OpenMPKinds.def"
626     default:
627       break;
628     }
629     break;
630   case OMPD_target_parallel_for:
631     switch (CKind) {
632 #define OPENMP_TARGET_PARALLEL_FOR_CLAUSE(Name)                                \
633   case OMPC_##Name:                                                            \
634     return true;
635 #include "clang/Basic/OpenMPKinds.def"
636     default:
637       break;
638     }
639     break;
640   case OMPD_target_update:
641     switch (CKind) {
642 #define OPENMP_TARGET_UPDATE_CLAUSE(Name)                                      \
643   case OMPC_##Name:                                                            \
644     return true;
645 #include "clang/Basic/OpenMPKinds.def"
646     default:
647       break;
648     }
649     break;
650   case OMPD_teams:
651     switch (CKind) {
652 #define OPENMP_TEAMS_CLAUSE(Name)                                              \
653   case OMPC_##Name:                                                            \
654     return true;
655 #include "clang/Basic/OpenMPKinds.def"
656     default:
657       break;
658     }
659     break;
660   case OMPD_cancel:
661     switch (CKind) {
662 #define OPENMP_CANCEL_CLAUSE(Name)                                             \
663   case OMPC_##Name:                                                            \
664     return true;
665 #include "clang/Basic/OpenMPKinds.def"
666     default:
667       break;
668     }
669     break;
670   case OMPD_ordered:
671     switch (CKind) {
672 #define OPENMP_ORDERED_CLAUSE(Name)                                            \
673   case OMPC_##Name:                                                            \
674     return true;
675 #include "clang/Basic/OpenMPKinds.def"
676     default:
677       break;
678     }
679     break;
680   case OMPD_taskloop:
681     switch (CKind) {
682 #define OPENMP_TASKLOOP_CLAUSE(Name)                                           \
683   case OMPC_##Name:                                                            \
684     return true;
685 #include "clang/Basic/OpenMPKinds.def"
686     default:
687       break;
688     }
689     break;
690   case OMPD_taskloop_simd:
691     switch (CKind) {
692 #define OPENMP_TASKLOOP_SIMD_CLAUSE(Name)                                      \
693   case OMPC_##Name:                                                            \
694     return true;
695 #include "clang/Basic/OpenMPKinds.def"
696     default:
697       break;
698     }
699     break;
700   case OMPD_master_taskloop:
701     switch (CKind) {
702 #define OPENMP_MASTER_TASKLOOP_CLAUSE(Name)                                    \
703   case OMPC_##Name:                                                            \
704     return true;
705 #include "clang/Basic/OpenMPKinds.def"
706     default:
707       break;
708     }
709     break;
710   case OMPD_master_taskloop_simd:
711     switch (CKind) {
712 #define OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(Name)                               \
713   case OMPC_##Name:                                                            \
714     return true;
715 #include "clang/Basic/OpenMPKinds.def"
716     default:
717       break;
718     }
719     break;
720   case OMPD_parallel_master_taskloop:
721     switch (CKind) {
722 #define OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(Name)                           \
723   case OMPC_##Name:                                                            \
724     return true;
725 #include "clang/Basic/OpenMPKinds.def"
726     default:
727       break;
728     }
729     break;
730   case OMPD_parallel_master_taskloop_simd:
731     switch (CKind) {
732 #define OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(Name)                      \
733   case OMPC_##Name:                                                            \
734     return true;
735 #include "clang/Basic/OpenMPKinds.def"
736     default:
737       break;
738     }
739     break;
740   case OMPD_critical:
741     switch (CKind) {
742 #define OPENMP_CRITICAL_CLAUSE(Name)                                           \
743   case OMPC_##Name:                                                            \
744     return true;
745 #include "clang/Basic/OpenMPKinds.def"
746     default:
747       break;
748     }
749     break;
750   case OMPD_distribute:
751     switch (CKind) {
752 #define OPENMP_DISTRIBUTE_CLAUSE(Name)                                         \
753   case OMPC_##Name:                                                            \
754     return true;
755 #include "clang/Basic/OpenMPKinds.def"
756     default:
757       break;
758     }
759     break;
760   case OMPD_distribute_parallel_for:
761     switch (CKind) {
762 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name)                            \
763   case OMPC_##Name:                                                            \
764     return true;
765 #include "clang/Basic/OpenMPKinds.def"
766     default:
767       break;
768     }
769     break;
770   case OMPD_distribute_parallel_for_simd:
771     switch (CKind) {
772 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name)                       \
773   case OMPC_##Name:                                                            \
774     return true;
775 #include "clang/Basic/OpenMPKinds.def"
776     default:
777       break;
778     }
779     break;
780   case OMPD_distribute_simd:
781     switch (CKind) {
782 #define OPENMP_DISTRIBUTE_SIMD_CLAUSE(Name)                                    \
783   case OMPC_##Name:                                                            \
784     return true;
785 #include "clang/Basic/OpenMPKinds.def"
786     default:
787       break;
788     }
789     break;
790   case OMPD_target_parallel_for_simd:
791     switch (CKind) {
792 #define OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(Name)                           \
793   case OMPC_##Name:                                                            \
794     return true;
795 #include "clang/Basic/OpenMPKinds.def"
796     default:
797       break;
798     }
799     break;
800   case OMPD_target_simd:
801     switch (CKind) {
802 #define OPENMP_TARGET_SIMD_CLAUSE(Name)                                        \
803   case OMPC_##Name:                                                            \
804     return true;
805 #include "clang/Basic/OpenMPKinds.def"
806     default:
807       break;
808     }
809     break;
810   case OMPD_teams_distribute:
811     switch (CKind) {
812 #define OPENMP_TEAMS_DISTRIBUTE_CLAUSE(Name)                                   \
813   case OMPC_##Name:                                                            \
814     return true;
815 #include "clang/Basic/OpenMPKinds.def"
816     default:
817       break;
818     }
819     break;
820   case OMPD_teams_distribute_simd:
821     switch (CKind) {
822 #define OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name)                              \
823   case OMPC_##Name:                                                            \
824     return true;
825 #include "clang/Basic/OpenMPKinds.def"
826     default:
827       break;
828     }
829     break;
830   case OMPD_teams_distribute_parallel_for_simd:
831     switch (CKind) {
832 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name)                 \
833   case OMPC_##Name:                                                            \
834     return true;
835 #include "clang/Basic/OpenMPKinds.def"
836     default:
837       break;
838     }
839     break;
840   case OMPD_teams_distribute_parallel_for:
841     switch (CKind) {
842 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name)                      \
843   case OMPC_##Name:                                                            \
844     return true;
845 #include "clang/Basic/OpenMPKinds.def"
846     default:
847       break;
848     }
849     break;
850   case OMPD_target_teams:
851     switch (CKind) {
852 #define OPENMP_TARGET_TEAMS_CLAUSE(Name)                                       \
853   case OMPC_##Name:                                                            \
854     return true;
855 #include "clang/Basic/OpenMPKinds.def"
856     default:
857       break;
858     }
859     break;
860   case OMPD_target_teams_distribute:
861     switch (CKind) {
862 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(Name)                            \
863   case OMPC_##Name:                                                            \
864     return true;
865 #include "clang/Basic/OpenMPKinds.def"
866     default:
867       break;
868     }
869     break;
870   case OMPD_target_teams_distribute_parallel_for:
871     switch (CKind) {
872 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name)               \
873   case OMPC_##Name:                                                            \
874     return true;
875 #include "clang/Basic/OpenMPKinds.def"
876     default:
877       break;
878     }
879     break;
880   case OMPD_target_teams_distribute_parallel_for_simd:
881     switch (CKind) {
882 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name)          \
883   case OMPC_##Name:                                                            \
884     return true;
885 #include "clang/Basic/OpenMPKinds.def"
886     default:
887       break;
888     }
889     break;
890   case OMPD_target_teams_distribute_simd:
891     switch (CKind) {
892 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name)                       \
893   case OMPC_##Name:                                                            \
894     return true;
895 #include "clang/Basic/OpenMPKinds.def"
896     default:
897       break;
898     }
899     break;
900   case OMPD_taskgroup:
901     switch (CKind) {
902 #define OPENMP_TASKGROUP_CLAUSE(Name)                                          \
903   case OMPC_##Name:                                                            \
904     return true;
905 #include "clang/Basic/OpenMPKinds.def"
906     default:
907       break;
908     }
909     break;
910   case OMPD_declare_mapper:
911     switch (CKind) {
912 #define OPENMP_DECLARE_MAPPER_CLAUSE(Name)                                     \
913   case OMPC_##Name:                                                            \
914     return true;
915 #include "clang/Basic/OpenMPKinds.def"
916     default:
917       break;
918     }
919     break;
920   case OMPD_allocate:
921     switch (CKind) {
922 #define OPENMP_ALLOCATE_CLAUSE(Name)                                           \
923   case OMPC_##Name:                                                            \
924     return true;
925 #include "clang/Basic/OpenMPKinds.def"
926     default:
927       break;
928     }
929     break;
930   case OMPD_declare_variant:
931     switch (CKind) {
932 #define OPENMP_DECLARE_VARIANT_CLAUSE(Name)                                    \
933   case OMPC_##Name:                                                            \
934     return true;
935 #include "clang/Basic/OpenMPKinds.def"
936     default:
937       break;
938     }
939     break;
940   case OMPD_declare_target:
941   case OMPD_end_declare_target:
942   case OMPD_unknown:
943   case OMPD_threadprivate:
944   case OMPD_section:
945   case OMPD_master:
946   case OMPD_taskyield:
947   case OMPD_barrier:
948   case OMPD_taskwait:
949   case OMPD_cancellation_point:
950   case OMPD_declare_reduction:
951   case OMPD_declare_simd:
952     break;
953   }
954   return false;
955 }
956 
957 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
958   return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
959          DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
960          DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
961          DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd ||
962          DKind == OMPD_parallel_master_taskloop ||
963          DKind == OMPD_parallel_master_taskloop_simd ||
964          DKind == OMPD_distribute || DKind == OMPD_target_parallel_for ||
965          DKind == OMPD_distribute_parallel_for ||
966          DKind == OMPD_distribute_parallel_for_simd ||
967          DKind == OMPD_distribute_simd ||
968          DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
969          DKind == OMPD_teams_distribute ||
970          DKind == OMPD_teams_distribute_simd ||
971          DKind == OMPD_teams_distribute_parallel_for_simd ||
972          DKind == OMPD_teams_distribute_parallel_for ||
973          DKind == OMPD_target_teams_distribute ||
974          DKind == OMPD_target_teams_distribute_parallel_for ||
975          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
976          DKind == OMPD_target_teams_distribute_simd;
977 }
978 
979 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
980   return DKind == OMPD_for || DKind == OMPD_for_simd ||
981          DKind == OMPD_sections || DKind == OMPD_section ||
982          DKind == OMPD_single || DKind == OMPD_parallel_for ||
983          DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
984          DKind == OMPD_target_parallel_for ||
985          DKind == OMPD_distribute_parallel_for ||
986          DKind == OMPD_distribute_parallel_for_simd ||
987          DKind == OMPD_target_parallel_for_simd ||
988          DKind == OMPD_teams_distribute_parallel_for_simd ||
989          DKind == OMPD_teams_distribute_parallel_for ||
990          DKind == OMPD_target_teams_distribute_parallel_for ||
991          DKind == OMPD_target_teams_distribute_parallel_for_simd;
992 }
993 
994 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) {
995   return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
996          DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd ||
997          DKind == OMPD_parallel_master_taskloop ||
998          DKind == OMPD_parallel_master_taskloop_simd;
999 }
1000 
1001 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
1002   return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
1003          DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
1004          DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for ||
1005          DKind == OMPD_distribute_parallel_for ||
1006          DKind == OMPD_distribute_parallel_for_simd ||
1007          DKind == OMPD_target_parallel_for_simd ||
1008          DKind == OMPD_teams_distribute_parallel_for ||
1009          DKind == OMPD_teams_distribute_parallel_for_simd ||
1010          DKind == OMPD_target_teams_distribute_parallel_for ||
1011          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
1012          DKind == OMPD_parallel_master_taskloop ||
1013          DKind == OMPD_parallel_master_taskloop_simd;
1014 }
1015 
1016 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) {
1017   return DKind == OMPD_target || DKind == OMPD_target_parallel ||
1018          DKind == OMPD_target_parallel_for ||
1019          DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
1020          DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
1021          DKind == OMPD_target_teams_distribute_parallel_for ||
1022          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
1023          DKind == OMPD_target_teams_distribute_simd;
1024 }
1025 
1026 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) {
1027   return DKind == OMPD_target_data || DKind == OMPD_target_enter_data ||
1028          DKind == OMPD_target_exit_data || DKind == OMPD_target_update;
1029 }
1030 
1031 bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) {
1032   return DKind == OMPD_teams || DKind == OMPD_teams_distribute ||
1033          DKind == OMPD_teams_distribute_simd ||
1034          DKind == OMPD_teams_distribute_parallel_for_simd ||
1035          DKind == OMPD_teams_distribute_parallel_for;
1036 }
1037 
1038 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) {
1039   return isOpenMPNestingTeamsDirective(DKind) ||
1040          DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
1041          DKind == OMPD_target_teams_distribute_parallel_for ||
1042          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
1043          DKind == OMPD_target_teams_distribute_simd;
1044 }
1045 
1046 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
1047   return DKind == OMPD_simd || DKind == OMPD_for_simd ||
1048          DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd ||
1049          DKind == OMPD_master_taskloop_simd ||
1050          DKind == OMPD_parallel_master_taskloop_simd ||
1051          DKind == OMPD_distribute_parallel_for_simd ||
1052          DKind == OMPD_distribute_simd || DKind == OMPD_target_simd ||
1053          DKind == OMPD_teams_distribute_simd ||
1054          DKind == OMPD_teams_distribute_parallel_for_simd ||
1055          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
1056          DKind == OMPD_target_teams_distribute_simd ||
1057          DKind == OMPD_target_parallel_for_simd;
1058 }
1059 
1060 bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) {
1061   return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for ||
1062          Kind == OMPD_distribute_parallel_for_simd ||
1063          Kind == OMPD_distribute_simd;
1064   // TODO add next directives.
1065 }
1066 
1067 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) {
1068   return isOpenMPNestingDistributeDirective(Kind) ||
1069          Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd ||
1070          Kind == OMPD_teams_distribute_parallel_for_simd ||
1071          Kind == OMPD_teams_distribute_parallel_for ||
1072          Kind == OMPD_target_teams_distribute ||
1073          Kind == OMPD_target_teams_distribute_parallel_for ||
1074          Kind == OMPD_target_teams_distribute_parallel_for_simd ||
1075          Kind == OMPD_target_teams_distribute_simd;
1076 }
1077 
1078 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
1079   return Kind == OMPC_private || Kind == OMPC_firstprivate ||
1080          Kind == OMPC_lastprivate || Kind == OMPC_linear ||
1081          Kind == OMPC_reduction || Kind == OMPC_task_reduction ||
1082          Kind == OMPC_in_reduction; // TODO add next clauses like 'reduction'.
1083 }
1084 
1085 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
1086   return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
1087 }
1088 
1089 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) {
1090   return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind);
1091 }
1092 
1093 bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) {
1094   return Kind == OMPD_distribute_parallel_for ||
1095          Kind == OMPD_distribute_parallel_for_simd ||
1096          Kind == OMPD_teams_distribute_parallel_for_simd ||
1097          Kind == OMPD_teams_distribute_parallel_for ||
1098          Kind == OMPD_target_teams_distribute_parallel_for ||
1099          Kind == OMPD_target_teams_distribute_parallel_for_simd;
1100 }
1101 
1102 void clang::getOpenMPCaptureRegions(
1103     SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions,
1104     OpenMPDirectiveKind DKind) {
1105   assert(DKind <= OMPD_unknown);
1106   switch (DKind) {
1107   case OMPD_parallel:
1108   case OMPD_parallel_for:
1109   case OMPD_parallel_for_simd:
1110   case OMPD_parallel_sections:
1111   case OMPD_distribute_parallel_for:
1112   case OMPD_distribute_parallel_for_simd:
1113     CaptureRegions.push_back(OMPD_parallel);
1114     break;
1115   case OMPD_target_teams:
1116   case OMPD_target_teams_distribute:
1117   case OMPD_target_teams_distribute_simd:
1118     CaptureRegions.push_back(OMPD_task);
1119     CaptureRegions.push_back(OMPD_target);
1120     CaptureRegions.push_back(OMPD_teams);
1121     break;
1122   case OMPD_teams:
1123   case OMPD_teams_distribute:
1124   case OMPD_teams_distribute_simd:
1125     CaptureRegions.push_back(OMPD_teams);
1126     break;
1127   case OMPD_target:
1128   case OMPD_target_simd:
1129     CaptureRegions.push_back(OMPD_task);
1130     CaptureRegions.push_back(OMPD_target);
1131     break;
1132   case OMPD_teams_distribute_parallel_for:
1133   case OMPD_teams_distribute_parallel_for_simd:
1134     CaptureRegions.push_back(OMPD_teams);
1135     CaptureRegions.push_back(OMPD_parallel);
1136     break;
1137   case OMPD_target_parallel:
1138   case OMPD_target_parallel_for:
1139   case OMPD_target_parallel_for_simd:
1140     CaptureRegions.push_back(OMPD_task);
1141     CaptureRegions.push_back(OMPD_target);
1142     CaptureRegions.push_back(OMPD_parallel);
1143     break;
1144   case OMPD_task:
1145   case OMPD_target_enter_data:
1146   case OMPD_target_exit_data:
1147   case OMPD_target_update:
1148     CaptureRegions.push_back(OMPD_task);
1149     break;
1150   case OMPD_taskloop:
1151   case OMPD_taskloop_simd:
1152   case OMPD_master_taskloop:
1153   case OMPD_master_taskloop_simd:
1154     CaptureRegions.push_back(OMPD_taskloop);
1155     break;
1156   case OMPD_parallel_master_taskloop:
1157   case OMPD_parallel_master_taskloop_simd:
1158     CaptureRegions.push_back(OMPD_parallel);
1159     CaptureRegions.push_back(OMPD_taskloop);
1160     break;
1161   case OMPD_target_teams_distribute_parallel_for:
1162   case OMPD_target_teams_distribute_parallel_for_simd:
1163     CaptureRegions.push_back(OMPD_task);
1164     CaptureRegions.push_back(OMPD_target);
1165     CaptureRegions.push_back(OMPD_teams);
1166     CaptureRegions.push_back(OMPD_parallel);
1167     break;
1168   case OMPD_simd:
1169   case OMPD_for:
1170   case OMPD_for_simd:
1171   case OMPD_sections:
1172   case OMPD_section:
1173   case OMPD_single:
1174   case OMPD_master:
1175   case OMPD_critical:
1176   case OMPD_taskgroup:
1177   case OMPD_distribute:
1178   case OMPD_ordered:
1179   case OMPD_atomic:
1180   case OMPD_target_data:
1181   case OMPD_distribute_simd:
1182     CaptureRegions.push_back(OMPD_unknown);
1183     break;
1184   case OMPD_threadprivate:
1185   case OMPD_allocate:
1186   case OMPD_taskyield:
1187   case OMPD_barrier:
1188   case OMPD_taskwait:
1189   case OMPD_cancellation_point:
1190   case OMPD_cancel:
1191   case OMPD_flush:
1192   case OMPD_declare_reduction:
1193   case OMPD_declare_mapper:
1194   case OMPD_declare_simd:
1195   case OMPD_declare_target:
1196   case OMPD_end_declare_target:
1197   case OMPD_requires:
1198   case OMPD_declare_variant:
1199     llvm_unreachable("OpenMP Directive is not allowed");
1200   case OMPD_unknown:
1201     llvm_unreachable("Unknown OpenMP directive");
1202   }
1203 }
1204