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